Repository: R-Fuzz/symsan Branch: main Commit: 79ebb2e08cc7 Files: 483 Total size: 4.7 MB Directory structure: gitextract_05a7zgkf/ ├── .github/ │ └── workflows/ │ └── test.yml ├── .gitignore ├── CMakeLists.txt ├── Dockerfile ├── LICENSE ├── README.md ├── backend/ │ ├── CMakeLists.txt │ └── fastgen.cpp ├── compiler/ │ ├── CMakeLists.txt │ └── ko_clang.c ├── driver/ │ ├── CMakeLists.txt │ ├── aflpp/ │ │ ├── CMakeLists.txt │ │ ├── README.md │ │ ├── rgd.proto │ │ └── symsan.cpp │ ├── fgtest.cpp │ ├── harness-proxy.c │ └── launcher/ │ ├── CMakeLists.txt │ └── launch.c ├── include/ │ ├── alloc_inl.h │ ├── ast.h │ ├── cov.h │ ├── debug.h │ ├── defs.h │ ├── launch.h │ ├── parse-rgd.h │ ├── parse-z3.h │ ├── parse.h │ ├── solver.h │ ├── task.h │ ├── task_mgr.h │ ├── union_find.h │ └── version.h ├── instrumentation/ │ ├── CMakeLists.txt │ └── TaintPass.cpp ├── parsers/ │ ├── CMakeLists.txt │ └── rgd-parser.cpp ├── python/ │ ├── CMakeLists.txt │ ├── README.md │ ├── symsan-py.cpp │ └── test.py ├── runtime/ │ ├── CMakeLists.txt │ ├── cmake/ │ │ ├── AddCompilerRT.cmake │ │ ├── BuiltinTests.cmake │ │ ├── CompilerRTCompile.cmake │ │ ├── CompilerRTDarwinUtils.cmake │ │ ├── CompilerRTLink.cmake │ │ ├── CompilerRTUtils.cmake │ │ ├── CustomLibcxx/ │ │ │ └── CMakeLists.txt │ │ ├── HandleCompilerRT.cmake │ │ └── SanitizerUtils.cmake │ ├── common_interface_defs.h │ ├── dfsan/ │ │ ├── .clang-format │ │ ├── CMakeLists.txt │ │ ├── dfsan.cpp │ │ ├── dfsan.h │ │ ├── dfsan.syms.extra │ │ ├── dfsan_custom.cpp │ │ ├── dfsan_flags.inc │ │ ├── dfsan_interceptors.cpp │ │ ├── dfsan_platform.h │ │ ├── done_abilist.txt │ │ ├── libc++_abilist.txt │ │ ├── libc_ubuntu1404_abilist.txt │ │ ├── libc_ubuntu1804_abilist.txt │ │ ├── libc_ubuntu2204_abilist.txt │ │ ├── libc_ubuntu2404_abilist.txt │ │ ├── scripts/ │ │ │ ├── build-libc-list.py │ │ │ └── check_custom_wrappers.sh │ │ ├── taint.ld │ │ ├── taint_allocator.cpp │ │ ├── taint_allocator.h │ │ ├── union_hashtable.cpp │ │ ├── union_hashtable.h │ │ ├── union_util.cpp │ │ └── union_util.h │ ├── interception/ │ │ ├── .clang-format │ │ ├── CMakeLists.txt │ │ ├── interception.h │ │ ├── interception_linux.cpp │ │ ├── interception_linux.h │ │ ├── interception_mac.cpp │ │ ├── interception_mac.h │ │ ├── interception_type_test.cpp │ │ ├── interception_win.cpp │ │ ├── interception_win.h │ │ └── tests/ │ │ ├── CMakeLists.txt │ │ ├── interception_linux_test.cpp │ │ ├── interception_test_main.cpp │ │ └── interception_win_test.cpp │ ├── libclang_rt.dfsan-x86_64.a.syms │ └── sanitizer_common/ │ ├── .clang-format │ ├── CMakeLists.txt │ ├── sancov_flags.cpp │ ├── sancov_flags.h │ ├── sancov_flags.inc │ ├── sanitizer_addrhashmap.h │ ├── sanitizer_allocator.cpp │ ├── sanitizer_allocator.h │ ├── sanitizer_allocator_bytemap.h │ ├── sanitizer_allocator_checks.cpp │ ├── sanitizer_allocator_checks.h │ ├── sanitizer_allocator_combined.h │ ├── sanitizer_allocator_dlsym.h │ ├── sanitizer_allocator_interface.h │ ├── sanitizer_allocator_internal.h │ ├── sanitizer_allocator_local_cache.h │ ├── sanitizer_allocator_primary32.h │ ├── sanitizer_allocator_primary64.h │ ├── sanitizer_allocator_report.cpp │ ├── sanitizer_allocator_report.h │ ├── sanitizer_allocator_secondary.h │ ├── sanitizer_allocator_size_class_map.h │ ├── sanitizer_allocator_stats.h │ ├── sanitizer_asm.h │ ├── sanitizer_atomic.h │ ├── sanitizer_atomic_clang.h │ ├── sanitizer_atomic_clang_mips.h │ ├── sanitizer_atomic_clang_other.h │ ├── sanitizer_atomic_clang_x86.h │ ├── sanitizer_atomic_msvc.h │ ├── sanitizer_bitvector.h │ ├── sanitizer_bvgraph.h │ ├── sanitizer_chained_origin_depot.cpp │ ├── sanitizer_chained_origin_depot.h │ ├── sanitizer_common.cpp │ ├── sanitizer_common.h │ ├── sanitizer_common_interceptors.inc │ ├── sanitizer_common_interceptors_format.inc │ ├── sanitizer_common_interceptors_ioctl.inc │ ├── sanitizer_common_interceptors_netbsd_compat.inc │ ├── sanitizer_common_interceptors_vfork_aarch64.inc.S │ ├── sanitizer_common_interceptors_vfork_arm.inc.S │ ├── sanitizer_common_interceptors_vfork_i386.inc.S │ ├── sanitizer_common_interceptors_vfork_riscv64.inc.S │ ├── sanitizer_common_interceptors_vfork_x86_64.inc.S │ ├── sanitizer_common_interface.inc │ ├── sanitizer_common_interface_posix.inc │ ├── sanitizer_common_libcdep.cpp │ ├── sanitizer_common_nolibc.cpp │ ├── sanitizer_common_syscalls.inc │ ├── sanitizer_coverage_fuchsia.cpp │ ├── sanitizer_coverage_interface.inc │ ├── sanitizer_coverage_libcdep_new.cpp │ ├── sanitizer_coverage_win_dll_thunk.cpp │ ├── sanitizer_coverage_win_dynamic_runtime_thunk.cpp │ ├── sanitizer_coverage_win_sections.cpp │ ├── sanitizer_coverage_win_weak_interception.cpp │ ├── sanitizer_dbghelp.h │ ├── sanitizer_deadlock_detector.h │ ├── sanitizer_deadlock_detector1.cpp │ ├── sanitizer_deadlock_detector2.cpp │ ├── sanitizer_deadlock_detector_interface.h │ ├── sanitizer_dense_map.h │ ├── sanitizer_dense_map_info.h │ ├── sanitizer_errno.cpp │ ├── sanitizer_errno.h │ ├── sanitizer_errno_codes.h │ ├── sanitizer_file.cpp │ ├── sanitizer_file.h │ ├── sanitizer_flag_parser.cpp │ ├── sanitizer_flag_parser.h │ ├── sanitizer_flags.cpp │ ├── sanitizer_flags.h │ ├── sanitizer_flags.inc │ ├── sanitizer_flat_map.h │ ├── sanitizer_freebsd.h │ ├── sanitizer_fuchsia.cpp │ ├── sanitizer_fuchsia.h │ ├── sanitizer_getauxval.h │ ├── sanitizer_glibc_version.h │ ├── sanitizer_hash.h │ ├── sanitizer_interceptors_ioctl_netbsd.inc │ ├── sanitizer_interface_internal.h │ ├── sanitizer_internal_defs.h │ ├── sanitizer_leb128.h │ ├── sanitizer_lfstack.h │ ├── sanitizer_libc.cpp │ ├── sanitizer_libc.h │ ├── sanitizer_libignore.cpp │ ├── sanitizer_libignore.h │ ├── sanitizer_linux.cpp │ ├── sanitizer_linux.h │ ├── sanitizer_linux_libcdep.cpp │ ├── sanitizer_linux_s390.cpp │ ├── sanitizer_list.h │ ├── sanitizer_local_address_space_view.h │ ├── sanitizer_lzw.h │ ├── sanitizer_mac.cpp │ ├── sanitizer_mac.h │ ├── sanitizer_mac_libcdep.cpp │ ├── sanitizer_malloc_mac.inc │ ├── sanitizer_mutex.cpp │ ├── sanitizer_mutex.h │ ├── sanitizer_netbsd.cpp │ ├── sanitizer_openbsd.cpp │ ├── sanitizer_persistent_allocator.cpp │ ├── sanitizer_persistent_allocator.h │ ├── sanitizer_placement_new.h │ ├── sanitizer_platform.h │ ├── sanitizer_platform_interceptors.h │ ├── sanitizer_platform_limits_freebsd.cpp │ ├── sanitizer_platform_limits_freebsd.h │ ├── sanitizer_platform_limits_linux.cpp │ ├── sanitizer_platform_limits_netbsd.cpp │ ├── sanitizer_platform_limits_netbsd.h │ ├── sanitizer_platform_limits_openbsd.cpp │ ├── sanitizer_platform_limits_openbsd.h │ ├── sanitizer_platform_limits_posix.cpp │ ├── sanitizer_platform_limits_posix.h │ ├── sanitizer_platform_limits_solaris.cpp │ ├── sanitizer_platform_limits_solaris.h │ ├── sanitizer_posix.cpp │ ├── sanitizer_posix.h │ ├── sanitizer_posix_libcdep.cpp │ ├── sanitizer_printf.cpp │ ├── sanitizer_procmaps.h │ ├── sanitizer_procmaps_bsd.cpp │ ├── sanitizer_procmaps_common.cpp │ ├── sanitizer_procmaps_fuchsia.cpp │ ├── sanitizer_procmaps_linux.cpp │ ├── sanitizer_procmaps_mac.cpp │ ├── sanitizer_procmaps_solaris.cpp │ ├── sanitizer_ptrauth.h │ ├── sanitizer_quarantine.h │ ├── sanitizer_report_decorator.h │ ├── sanitizer_ring_buffer.h │ ├── sanitizer_rtems.cpp │ ├── sanitizer_rtems.h │ ├── sanitizer_signal_interceptors.inc │ ├── sanitizer_solaris.cpp │ ├── sanitizer_stack_store.cpp │ ├── sanitizer_stack_store.h │ ├── sanitizer_stackdepot.cpp │ ├── sanitizer_stackdepot.h │ ├── sanitizer_stackdepotbase.h │ ├── sanitizer_stacktrace.cpp │ ├── sanitizer_stacktrace.h │ ├── sanitizer_stacktrace_libcdep.cpp │ ├── sanitizer_stacktrace_printer.cpp │ ├── sanitizer_stacktrace_printer.h │ ├── sanitizer_stacktrace_sparc.cpp │ ├── sanitizer_stoptheworld.h │ ├── sanitizer_stoptheworld_fuchsia.cpp │ ├── sanitizer_stoptheworld_fuchsia.h │ ├── sanitizer_stoptheworld_linux_libcdep.cpp │ ├── sanitizer_stoptheworld_mac.cpp │ ├── sanitizer_stoptheworld_netbsd_libcdep.cpp │ ├── sanitizer_stoptheworld_win.cpp │ ├── sanitizer_suppressions.cpp │ ├── sanitizer_suppressions.h │ ├── sanitizer_symbolizer.cpp │ ├── sanitizer_symbolizer.h │ ├── sanitizer_symbolizer_fuchsia.h │ ├── sanitizer_symbolizer_internal.h │ ├── sanitizer_symbolizer_libbacktrace.cpp │ ├── sanitizer_symbolizer_libbacktrace.h │ ├── sanitizer_symbolizer_libcdep.cpp │ ├── sanitizer_symbolizer_mac.cpp │ ├── sanitizer_symbolizer_mac.h │ ├── sanitizer_symbolizer_markup.cpp │ ├── sanitizer_symbolizer_posix_libcdep.cpp │ ├── sanitizer_symbolizer_report.cpp │ ├── sanitizer_symbolizer_rtems.h │ ├── sanitizer_symbolizer_win.cpp │ ├── sanitizer_syscall_generic.inc │ ├── sanitizer_syscall_linux_aarch64.inc │ ├── sanitizer_syscall_linux_arm.inc │ ├── sanitizer_syscall_linux_hexagon.inc │ ├── sanitizer_syscall_linux_riscv64.inc │ ├── sanitizer_syscall_linux_x86_64.inc │ ├── sanitizer_syscalls_netbsd.inc │ ├── sanitizer_termination.cpp │ ├── sanitizer_thread_registry.cpp │ ├── sanitizer_thread_registry.h │ ├── sanitizer_thread_safety.h │ ├── sanitizer_tls_get_addr.cpp │ ├── sanitizer_tls_get_addr.h │ ├── sanitizer_type_traits.cpp │ ├── sanitizer_type_traits.h │ ├── sanitizer_unwind_linux_libcdep.cpp │ ├── sanitizer_unwind_win.cpp │ ├── sanitizer_vector.h │ ├── sanitizer_win.cpp │ ├── sanitizer_win.h │ ├── sanitizer_win_defs.h │ ├── sanitizer_win_dll_thunk.cpp │ ├── sanitizer_win_dll_thunk.h │ ├── sanitizer_win_dynamic_runtime_thunk.cpp │ ├── sanitizer_win_weak_interception.cpp │ ├── sanitizer_win_weak_interception.h │ ├── scripts/ │ │ ├── check_lint.sh │ │ ├── cpplint.py │ │ ├── gen_dynamic_list.py │ │ ├── litlint.py │ │ ├── litlint_test.py │ │ └── sancov.py │ ├── symbolizer/ │ │ ├── sanitizer_symbolize.cpp │ │ ├── sanitizer_wrappers.cpp │ │ └── scripts/ │ │ ├── ar_to_bc.sh │ │ ├── build_symbolizer.sh │ │ └── global_symbols.txt │ ├── tests/ │ │ ├── CMakeLists.txt │ │ ├── malloc_stress_transfer_test.cpp │ │ ├── sanitizer_addrhashmap_test.cpp │ │ ├── sanitizer_allocator_test.cpp │ │ ├── sanitizer_allocator_testlib.cpp │ │ ├── sanitizer_atomic_test.cpp │ │ ├── sanitizer_bitvector_test.cpp │ │ ├── sanitizer_bvgraph_test.cpp │ │ ├── sanitizer_chained_origin_depot_test.cpp │ │ ├── sanitizer_common_test.cpp │ │ ├── sanitizer_deadlock_detector_test.cpp │ │ ├── sanitizer_dense_map_test.cpp │ │ ├── sanitizer_flags_test.cpp │ │ ├── sanitizer_flat_map_test.cpp │ │ ├── sanitizer_format_interceptor_test.cpp │ │ ├── sanitizer_hash_test.cpp │ │ ├── sanitizer_ioctl_test.cpp │ │ ├── sanitizer_leb128_test.cpp │ │ ├── sanitizer_libc_test.cpp │ │ ├── sanitizer_linux_test.cpp │ │ ├── sanitizer_list_test.cpp │ │ ├── sanitizer_lzw_test.cpp │ │ ├── sanitizer_mac_test.cpp │ │ ├── sanitizer_mutex_test.cpp │ │ ├── sanitizer_nolibc_test.cpp │ │ ├── sanitizer_nolibc_test_main.cpp │ │ ├── sanitizer_posix_test.cpp │ │ ├── sanitizer_printf_test.cpp │ │ ├── sanitizer_procmaps_test.cpp │ │ ├── sanitizer_pthread_wrappers.h │ │ ├── sanitizer_quarantine_test.cpp │ │ ├── sanitizer_ring_buffer_test.cpp │ │ ├── sanitizer_stack_store_test.cpp │ │ ├── sanitizer_stackdepot_test.cpp │ │ ├── sanitizer_stacktrace_printer_test.cpp │ │ ├── sanitizer_stacktrace_test.cpp │ │ ├── sanitizer_stoptheworld_test.cpp │ │ ├── sanitizer_stoptheworld_testlib.cpp │ │ ├── sanitizer_suppressions_test.cpp │ │ ├── sanitizer_symbolizer_test.cpp │ │ ├── sanitizer_test_config.h │ │ ├── sanitizer_test_main.cpp │ │ ├── sanitizer_test_utils.h │ │ ├── sanitizer_thread_registry_test.cpp │ │ ├── sanitizer_type_traits_test.cpp │ │ ├── sanitizer_vector_test.cpp │ │ └── standalone_malloc_test.cpp │ └── weak_symbols.txt ├── solvers/ │ ├── CMakeLists.txt │ ├── i2s-solver.cpp │ ├── jigsaw/ │ │ ├── CMakeLists.txt │ │ ├── config.h │ │ ├── gd.cc │ │ ├── grad.cc │ │ ├── grad.h │ │ ├── input.cc │ │ ├── input.h │ │ ├── jit.cc │ │ ├── jit.h │ │ └── rgdJit.h │ ├── jit-solver.cpp │ ├── wheels/ │ │ ├── concurrentqueue/ │ │ │ └── queue.h │ │ ├── lockfreehash/ │ │ │ ├── cuckoo/ │ │ │ │ ├── Makefile │ │ │ │ ├── benchmark_lockfree_ht.h │ │ │ │ ├── benchmark_unordered_map.h │ │ │ │ ├── cycle_timer.h │ │ │ │ ├── hash_table.h │ │ │ │ ├── lockfree_hash_table.cpp │ │ │ │ ├── lockfree_hash_table.h │ │ │ │ ├── main.cpp │ │ │ │ └── thread_service.h │ │ │ └── lprobe/ │ │ │ ├── Makefile │ │ │ ├── alloc.h │ │ │ ├── benchmark_lprobe.h │ │ │ ├── benchmark_lprobe_ptr.h │ │ │ ├── block_allocator.h │ │ │ ├── concurrent_stack.h │ │ │ ├── cycle_timer.h │ │ │ ├── data.h │ │ │ ├── data_ptr.h │ │ │ ├── get_time.h │ │ │ ├── hash_table.h │ │ │ ├── main.cc │ │ │ ├── memory_size.h │ │ │ ├── monoid.h │ │ │ ├── parallel.h │ │ │ ├── seq.h │ │ │ ├── sequence_ops.h │ │ │ ├── thread_service.h │ │ │ ├── thread_service_ptr.h │ │ │ └── utilities.h │ │ └── threadpool/ │ │ ├── ThreadPool.h │ │ ├── ctpl.h │ │ └── threadpool_example.cpp │ ├── z3-solver.cpp │ ├── z3-ts.cpp │ └── z3.cpp ├── tests/ │ ├── CMakeLists.txt │ ├── aggregate.c │ ├── atoi_test.c │ ├── atomicrmw.c │ ├── bitflip.c │ ├── bool.c │ ├── boundary.c │ ├── boundary2.c │ ├── boundary3.c │ ├── boundary4.c │ ├── boundary5.c │ ├── boundary6.c │ ├── boundary7.c │ ├── bounds.cpp │ ├── call_fn.c │ ├── call_fn2.c │ ├── call_fn3.c │ ├── cf1.c │ ├── concrete_haystack.c │ ├── context.c │ ├── cpp_fstream.cpp │ ├── cpp_map.cpp │ ├── cpp_string.cpp │ ├── gep.c │ ├── if_eq.c │ ├── infer_type.c │ ├── lib.h │ ├── lit.cfg │ ├── lit.site.cfg.in │ ├── memchr.c │ ├── memchr_chain.c │ ├── memchr_mixed_chain.c │ ├── memcmp.c │ ├── memmem.c │ ├── memrchr.c │ ├── memrchr_chain.c │ ├── mini.c │ ├── mini2.c │ ├── optimistic.c │ ├── partial_concrete.c │ ├── partial_concrete2.c │ ├── partial_concrete3.c │ ├── pointer.c │ ├── prefixof.c │ ├── shift_and.c │ ├── sign.c │ ├── str_mem_mixed_chain.c │ ├── strcat.c │ ├── strcat_mixed.c │ ├── strchr.c │ ├── strchr_chain.c │ ├── strchr_mixed_chain.c │ ├── strcmp.c │ ├── strcmp2.c │ ├── strdup.c │ ├── strlen_extend.c │ ├── strlen_json3.c │ ├── strlen_null_from_input.c │ ├── strlen_shrink.c │ ├── strlen_test.c │ ├── strncat.c │ ├── strncpy_simple.c │ ├── strncpy_substr.c │ ├── strndup.c │ ├── strnstr.c │ ├── strpbrk.c │ ├── strrchr.c │ ├── strstr.c │ ├── strsub.c │ ├── struct.c │ ├── switch.c │ ├── ubsan_div.c │ ├── ubsan_intovfl.c │ ├── ubsan_mulovfl.c │ ├── ubsan_negateovfl.c │ ├── ubsan_shift.c │ ├── ubsan_signchange.c │ ├── ubsan_signed_intovfl.c │ ├── ubsan_subovfl.c │ ├── ubsan_trunc.c │ ├── unaligned_load.c │ └── xor_bool.c └── wrappers/ ├── CMakeLists.txt └── zlib_abilist.txt ================================================ FILE CONTENTS ================================================ ================================================ FILE: .github/workflows/test.yml ================================================ name: CI on: pull_request: branches: [ main ] push: branches: - main paths: - '!README.md' jobs: build-and-test: runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v4 - name: install dependencies run: sudo apt-get update && sudo apt-get install -y llvm-14 clang-14 libc++-14-dev libc++abi-14-dev python3-minimal libgoogle-perftools-dev libboost-container-dev python3-dev libbsd-dev - name: Cache Z3 id: cache-z3 uses: actions/cache@v4 with: path: ~/z3 key: z3-4.15.4-x64-glibc-2.39 - name: Install Z3 run: | if [ ! -d ~/z3 ]; then wget https://github.com/Z3Prover/z3/releases/download/z3-4.15.4/z3-4.15.4-x64-glibc-2.39.zip unzip z3-4.15.4-x64-glibc-2.39.zip mv z3-4.15.4-x64-glibc-2.39 ~/z3 fi sudo cp ~/z3/bin/z3 /usr/local/bin/ sudo cp ~/z3/bin/libz3.so /usr/local/lib/ sudo cp ~/z3/bin/libz3.a /usr/local/lib/ sudo cp -r ~/z3/include/* /usr/local/include/ sudo ldconfig # run: | # wget https://apt.llvm.org/llvm.sh # chmod +x llvm.sh # sudo ./llvm.sh 12 all - name: get aflpp uses: actions/checkout@v4 with: repository: AFLplusplus/AFLplusplus path: ${{ github.workspace }}/aflpp - name: configure run: CC=clang-14 CXX=clang++-14 cmake -B ${{ github.workspace }}/build -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/install -DAFLPP_PATH=${{ github.workspace }}/aflpp - name: build run: CC=clang-14 CXX=clang++-14 cmake --build ${{ github.workspace }}/build - name: install run: CC=clang-14 CXX=clang++-14 cmake --install ${{ github.workspace }}/build - name: install lit run: pip install lit - name: test run: lit --verbose tests working-directory: ${{ github.workspace }}/build ================================================ FILE: .gitignore ================================================ .vscode *.taint *.o *.so *.dwo *.bc *.ll GPATH GRTAGS GTAGS GSYMS output*/ *.tar.gz *.tar.xz auto/ /bin/ .DS_Store /build/ /libcxx/ !/libcxx/build_taint/lib/ /install ================================================ FILE: CMakeLists.txt ================================================ cmake_minimum_required(VERSION 3.13) project(symsan VERSION 1.2.2 LANGUAGES C CXX ASM) find_package(LLVM 14 REQUIRED CONFIG) # Find Z3 (minimum version 4.8.15 required for string theory APIs) # Prefer /usr/local over system find_library(Z3_LIBRARY NAMES z3 PATHS /usr/local/lib NO_DEFAULT_PATH) if (NOT Z3_LIBRARY) find_library(Z3_LIBRARY NAMES z3) endif() find_path(Z3_INCLUDE_DIR NAMES z3.h PATHS /usr/local/include NO_DEFAULT_PATH) if (NOT Z3_INCLUDE_DIR) find_path(Z3_INCLUDE_DIR NAMES z3.h) endif() # Check Z3 version if (Z3_INCLUDE_DIR) file(READ "${Z3_INCLUDE_DIR}/z3_version.h" Z3_VERSION_CONTENT) string(REGEX MATCH "#define Z3_MAJOR_VERSION[ \t]+([0-9]+)" _ "${Z3_VERSION_CONTENT}") set(Z3_VERSION_MAJOR ${CMAKE_MATCH_1}) string(REGEX MATCH "#define Z3_MINOR_VERSION[ \t]+([0-9]+)" _ "${Z3_VERSION_CONTENT}") set(Z3_VERSION_MINOR ${CMAKE_MATCH_1}) string(REGEX MATCH "#define Z3_BUILD_NUMBER[ \t]+([0-9]+)" _ "${Z3_VERSION_CONTENT}") set(Z3_VERSION_PATCH ${CMAKE_MATCH_1}) set(Z3_VERSION "${Z3_VERSION_MAJOR}.${Z3_VERSION_MINOR}.${Z3_VERSION_PATCH}") message(STATUS "Found Z3 version: ${Z3_VERSION}") # Require at least version 4.8.15 if (Z3_VERSION_MAJOR LESS 4 OR (Z3_VERSION_MAJOR EQUAL 4 AND Z3_VERSION_MINOR LESS 8) OR (Z3_VERSION_MAJOR EQUAL 4 AND Z3_VERSION_MINOR EQUAL 8 AND Z3_VERSION_PATCH LESS 15)) message(FATAL_ERROR "Z3 version ${Z3_VERSION} found, but version 4.8.15 or later is required (for string theory APIs)") endif() endif() message(STATUS "Z3_LIBRARY: ${Z3_LIBRARY}") message(STATUS "Z3_INCLUDE_DIR: ${Z3_INCLUDE_DIR}") message(STATUS "Z3_VERSION: ${Z3_VERSION}") if (LLVM_FOUND) message(STATUS "LLVM_VERSION_MAJOR: ${LLVM_VERSION_MAJOR}") message(STATUS "LLVM_VERSION_MINOR: ${LLVM_VERSION_MINOR}") message(STATUS "LLVM_VERSION_PATCH: ${LLVM_VERSION_PATCH}") else() message(FATAL_ERROR "You haven't install LLVM !") endif() if (NOT TARGET LLVMPassConfig) add_library(LLVMPassConfig INTERFACE IMPORTED) set_target_properties(LLVMPassConfig PROPERTIES INTERFACE_COMPILE_OPTIONS "-fno-rtti" #-fpic INTERFACE_INCLUDE_DIRECTORIES "${LLVM_INCLUDE_DIRS}" INTERFACE_LINK_DIRECTORIES "${LLVM_LIBRARY_DIRS}" INTERFACE_COMPILE_DEFINITIONS "LLVM_VERSION_MAJOR=${LLVM_VERSION_MAJOR};LLVM_VERSION_MINOR=${LLVM_VERSION_MINOR};" # INTERFACE_LINK_OPTIONS "-Wl,-znodelete" ) endif() include_directories(${LLVM_INCLUDE_DIRS}) add_definitions(${LLVM_DEFINITIONS}) include_directories(include) set(SYMSAN_BIN_DIR "bin") set(SYMSAN_LIB_DIR "lib/symsan") add_subdirectory(compiler) add_subdirectory(instrumentation) add_subdirectory(runtime) add_subdirectory(wrappers) add_subdirectory(parsers) add_subdirectory(solvers) add_subdirectory(backend) add_subdirectory(driver) add_subdirectory(tests) add_subdirectory(libcxx) add_subdirectory(python) ================================================ FILE: Dockerfile ================================================ FROM ubuntu:noble ENV DEBIAN_FRONTEND=noninteractive ENV TZ=Etc/UTC ENV DEBIAN_FRONTEND=noninteractive ENV TZ=Etc/UTC WORKDIR /work COPY . /work/symsan RUN apt-get update RUN apt-get install -y cmake llvm-14 clang-14 libc++-14-dev libc++abi-14-dev libunwind-14-dev \ python3-minimal python-is-python3 zlib1g-dev git joe libprotobuf-dev RUN git clone --depth=1 --branch=v4.31c https://github.com/AFLplusplus/AFLplusplus /work/aflpp RUN cd /work/aflpp && make PERFORMANCE=1 LLVM_CONFIG=llvm-config-14 NO_NYX=1 source-only -j4 && make install RUN apt-get install -y libz3-dev libgoogle-perftools-dev libboost-container-dev python3-dev RUN apt clean RUN cd /work/symsan/ && mkdir -p build && \ cd build && CC=clang-14 CXX=clang++-14 cmake -DCMAKE_INSTALL_PREFIX=. -DAFLPP_PATH=/work/aflpp ../ && \ make -j4 && make install ENV KO_CC=clang-14 ENV KO_CXX=clang++-14 ENV KO_USE_FASTGEN=1 ================================================ FILE: LICENSE ================================================ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ================================================ FILE: README.md ================================================ [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) # SymSan: Time and Space Efficient Concolic Execution via Dynamic Data-Flow Analysis SymSan (Symbolic Sanitizer) is an efficient concolic execution engine based on the Data-Floow Sanitizer (DFSan) framework. By modeling forward symbolic execution as a dynamic data-flow analysis and leveraging the time and space efficient data-flow tracking infrastructure from DFSan, SymSan imposes much lower runtime overhead than previous symbolic execution engines. Similar to other compilation-based symbolic executor like [SymCC](https://github.com/eurecom-s3/symcc), SymSan uses compile-time `instrumentation` to insert symbolic execution logic into the target program, and a `runtime` supporting library to maintain symbolic states during execution. To learn more, checkout our [paper](https://www.usenix.org/conference/usenixsecurity22/presentation/chen-ju) at USENIX Security 2022. ## Building Because SymSan leverages the shadow memory implementation from LLVM's sanitizers, it has more strict dependency on the LLVM version. Right now only LLVM 12 is tested. ### Build Requirements - Linux-amd64 (Tested on Ubuntu 24.04) - [LLVM 14.0.6](http://llvm.org/docs/index.html): clang, libc++, libc++abi ### Compilation Create a `build` directory and execute the following commands in it: ```shell $ CC=clang-14 CXX=clang++-14 cmake -DCMAKE_INSTALL_PREFIX=/path/to/install -DCMAKE_BUILD_TYPE=Release /path/to/symsan/source $ make $ make install ``` ### Build in Docker ``` docker build -t symsan . ``` ### LIBCXX The repo contains instrumented libc++ and libc++abi to support C++ programs. To rebuild these libraries from source, execute the `rebuild.sh` script in the `libcxx` directory. **NOTE**: because the in-process solving module (`solver/z3.cpp`) uses Z3's C++ API and STL containers, so itself depends on the C++ libs. Due to such dependencies, you'll see linking errors when building C++ targets when using this module. Though it's possible to resolve these errors by not instrumenting the dependencies (adding them to the [ABIList](https://clang.llvm.org/docs/DataFlowSanitizer.html#abi-list), then rebuild the C++ libs), we don't recommend using it for C++ targets. Instead, it's much cleaner to use ann out-of-process solving module like Fastgen. ## Test To verify the code works, try some simple tests (forked from [Angora](https://github.com/AngoraFuzzer/Angora), adapted by [@insuyun](https://github.com/insuyun) to lit): ``` $ pip install lit $ cd your_build_dir $ lit tests ``` ### Environment Options * `KO_CC` specifies the clang to invoke, if the default version isn't clang-12, set this variable to allow the compiler wrapper to find the correct clang. * `KO_CXX` specifies the clang++ to invoke, if the default version isn't clang++-12, set this variable to allow the compiler wrapper to find the correct clang++. * `KO_USE_Z3` enables the in-process Z3-based solver. By default, it is disabled, so SymSan will only perform symbolic constraint collection without solving. SymSan also supports out-of-process solving, which provides better compatiblility. Check [FastGen](https://github.com/R-Fuzz/fastgen). * `KO_USE_NATIVE_LIBCXX` enables using the native uninstrumented libc++ and libc++abi. * `KO_DONT_OPTIMIZE` don't override the optimization level to `O3`. ### Hybrid Fuzzing SymSan needs a driver to perform hybrid fuzzing, like [FastGen](https://github.com/R-Fuzz/fastgen). It could also be used as a custom mutator for [AFL++](https://github.com/AFLplusplus/AFLplusplus) (check the [plugin readme](driver/aflpp/README.md)). Check out our integration with Magma to see how to compile and run targets: [aflplusplus_symsan](https://github.com/R-Fuzz/magma/tree/mazerunner/fuzzers/aflplusplus_symsan). It should also be easy to use the [Python binding](https://github.com/R-Fuzz/symsan/tree/main/python). NOTE: fgtest is for running tests, not for continnous fuzzing, please don't use it for benchmark. ## Documentation Still under construction, unfortunately. [DeepWiki](https://deepwiki.com/R-Fuzz/symsan) seems okay. ## Reference To cite SymSan in scientific work, please use the following BibTeX: ``` bibtex @inproceedings {chen2022symsan, author = {Ju Chen and Wookhyun Han and Mingjun Yin and Haochen Zeng and Chengyu Song and Byoungyong Lee and Heng Yin and Insik Shin}, title = {SymSan: Time and Space Efficient Concolic Execution via Dynamic Data-Flow Analysis}, booktitle = {{USENIX} Security Symposium (Security)}, year = 2022, url = {https://www.usenix.org/conference/usenixsecurity22/presentation/chen-ju}, publisher = {{USENIX} Association}, month = aug, } ``` ================================================ FILE: backend/CMakeLists.txt ================================================ set(CMAKE_POSITION_INDEPENDENT_CODE ON) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") add_library(Fastgen STATIC fastgen.cpp) target_compile_options(Fastgen PRIVATE -stdlib=libc++) target_include_directories(Fastgen PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../runtime ) install (TARGETS Fastgen DESTINATION ${SYMSAN_LIB_DIR}) ================================================ FILE: backend/fastgen.cpp ================================================ /* The code is for out-of-process constraints solving with fastgen. ------------------------------------------------ Written by Chengyu Song and Ju Chen Copyright 2021-2025 UC Riverside. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0 */ #include "sanitizer_common/sanitizer_common.h" #include "sanitizer_common/sanitizer_file.h" #include "sanitizer_common/sanitizer_posix.h" #include "dfsan/dfsan.h" using namespace __dfsan; static uint32_t __instance_id; static uint32_t __session_id; static int __pipe_fd; // filter? SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL uint32_t __taint_trace_callstack; static inline void __solve_cond(dfsan_label label, uint8_t result, uint8_t add_nested, uint8_t loop_flag, uint32_t cid, void *addr) { if (__pipe_fd < 0) return; uint16_t flags = 0; if (add_nested) flags |= F_ADD_CONS; // set the loop flags according to branching results switch (loop_flag) { case TrueBranchLoopExit: flags |= result ? F_LOOP_EXIT : F_LOOP_LATCH; break; case TrueBranchLoopLatch: flags |= result ? F_LOOP_LATCH : F_LOOP_EXIT; break; case FalseBranchLoopExit: flags |= result ? F_LOOP_LATCH : F_LOOP_EXIT; break; case FalseBranchLoopLatch: flags |= result ? F_LOOP_EXIT : F_LOOP_LATCH; break; default: // No loop flag or unrecognized flag, do nothing break; } // send info pipe_msg msg = { .msg_type = cond_type, .flags = flags, .instance_id = __instance_id, .addr = (uptr)addr, .context = __taint_trace_callstack, .id = cid, .label = label, .result = result }; if (internal_write(__pipe_fd, &msg, sizeof(msg)) < 0) { Die(); } } static inline void __send_ubi(dfsan_label label, uint64_t result, uint32_t cid, void *addr) { if (__pipe_fd < 0) return; pipe_msg msg = { .msg_type = memerr_type, .flags = F_MEMERR_UBI, .instance_id = __instance_id, .addr = (uptr)addr, .context = __taint_trace_callstack, .id = cid, .label = label, .result = result }; if (internal_write(__pipe_fd, &msg, sizeof(msg)) < 0) { Die(); } } static struct switch_true_case { dfsan_label label; uint32_t cid; } __switch_true_case = {0}; extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_cmp(dfsan_label op1, dfsan_label op2, uint32_t size, uint32_t predicate, uint64_t c1, uint64_t c2, uint32_t cid) { if (op1 == 0 && op2 == 0) return; void *addr = __builtin_return_address(0); if (op1 == kInitializingLabel) { // uninitialized label AOUT("WARNING: uninitialized label %u @%p\n", op1, addr); if (flags().solve_ub) __send_ubi(op1, c1, cid, addr); if (flags().exit_on_memerror) Die(); else return; } if (op2 == kInitializingLabel) { // uninitialized label AOUT("WARNING: uninitialized label %u @%p\n", op2, addr); if (flags().solve_ub) __send_ubi(op2, c2, cid, addr); if (flags().exit_on_memerror) Die(); else return; } AOUT("solving cmp: %u %u %u %d %lu %lu 0x%x @%p\n", op1, op2, size, predicate, c1, c2, cid, addr); // save info to a union table slot uint8_t r = get_const_result(c1, c2, predicate); dfsan_label temp = dfsan_union(op1, op2, (predicate << 8) | ICmp, size, c1, c2); if (r) { // for the true case, we want to save it to solve the last, // so the nested constraint will not affect other cases __switch_true_case.label = temp; __switch_true_case.cid = cid; } else { // solve without add_nested __solve_cond(temp, r, 0, 0, cid, addr); } } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_switch_end(uint32_t cid) { if (__switch_true_case.label == 0) { return; } else if (__switch_true_case.cid != cid) { AOUT("WARNING: switch end cid mismatch %u vs %u\n", __switch_true_case.cid, cid); return; } void *addr = __builtin_return_address(0); AOUT("solving switch end: %u 0x%x @%p\n", __switch_true_case.label, cid, addr); // solve the true case __solve_cond(__switch_true_case.label, 1, 1, 0, cid, addr); __switch_true_case.label = 0; } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_cond(dfsan_label label, bool r, uint8_t flag, uint32_t cid) { if (label == 0) { // check for real loop exit if (!(((flag & FalseBranchLoopExit) && !r) || ((flag & TrueBranchLoopExit) && r))) return; } void *addr = __builtin_return_address(0); if (label == kInitializingLabel) { // uninitialized label AOUT("WARNING: uninitialized label %u @%p\n", label, addr); if (flags().solve_ub) __send_ubi(label, r, cid, addr); if (flags().exit_on_memerror) Die(); else return; } AOUT("solving cond: %u %u 0x%x 0x%x %p\n", label, r, __taint_trace_callstack, cid, addr); uint8_t add_nested = flag & UndefinedCheck ? 0 : 1; uint8_t loop_flag = flag & LoopFlagMask; // always add nested __solve_cond(label, r, add_nested, loop_flag, cid, addr); } extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_label __taint_trace_select(dfsan_label cond_label, dfsan_label true_label, dfsan_label false_label, uint8_t r, uint8_t true_op, uint8_t false_op, uint32_t cid) { if (cond_label == 0) return r ? true_label : false_label; void *addr = __builtin_return_address(0); if (cond_label == kInitializingLabel) { // uninitialized label AOUT("WARNING: uninitialized label %u @%p\n", cond_label, addr); if (flags().solve_ub) __send_ubi(cond_label, r, cid, addr); if (flags().exit_on_memerror) Die(); else return r ? true_label : false_label; } AOUT("solving select: %u %u %u %u %u %u 0x%x @%p\n", cond_label, true_label, false_label, r, true_op, false_op, cid, addr); // check if it's actually a logical AND: select cond, label, false if (true_label != 0 && false_op == 0) { dfsan_label land = dfsan_union(cond_label, true_label, And, 1, r, true_op); uint8_t lr = (r && true_op) ? 1 : 0; __solve_cond(land, lr, 1, 0, cid, addr); return land; } else if (false_label != 0 && true_op == 1) { // logical OR: select cond, true, label dfsan_label lor = dfsan_union(cond_label, false_label, Or, 1, r, false_op); uint8_t lr = (r || false_op) ? 1 : 0; __solve_cond(lor, lr, 1, 0, cid, addr); return lor; } else { // normal select? AOUT("normal select?!\n"); __solve_cond(cond_label, r, 1, 0, cid, addr); return r ? true_label : false_label; } } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_indcall(dfsan_label label) { if (label == 0) return; AOUT("tainted indirect call target: %d\n", label); } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_gep(dfsan_label ptr_label, uint64_t ptr, dfsan_label index_label, int64_t index, uint64_t num_elems, uint64_t elem_size, int64_t current_offset, uint32_t cid) { if (index_label == 0) return; void *addr = __builtin_return_address(0); if (index_label == kInitializingLabel) { // uninitialized label AOUT("WARNING: uninitialized label %u @%p\n", index_label, addr); if (flags().solve_ub) __send_ubi(index_label, index, cid, addr); if (flags().exit_on_memerror) Die(); else return; } if (ptr_label == kInitializingLabel) { // uninitialized label AOUT("WARNING: uninitialized label %u @%p\n", ptr_label, addr); if (flags().solve_ub) __send_ubi(ptr_label, ptr, cid, addr); if (flags().exit_on_memerror) Die(); else return; } AOUT("tainted GEP index: %ld = %d, ne: %ld, es: %ld, offset: %ld\n", index, index_label, num_elems, elem_size, current_offset); if (__pipe_fd < 0) return; // send gep info, in two pieces pipe_msg msg = { .msg_type = gep_type, .flags = 0, .instance_id = __instance_id, .addr = (uptr)addr, .context = __taint_trace_callstack, .label = index_label, // just in case .result = (uint64_t)index }; if (internal_write(__pipe_fd, &msg, sizeof(msg)) < 0) { Die(); } gep_msg gmsg = { .ptr_label = ptr_label, .index_label = index_label, .ptr = ptr, .index = index, .num_elems = num_elems, .elem_size = elem_size, .current_offset = current_offset }; // FIXME: assuming single writer so msg will arrive in the same order if (internal_write(__pipe_fd, &gmsg, sizeof(gmsg)) < 0) { Die(); } return; } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_offset(dfsan_label offset_label, s64 offset, unsigned size) { return; } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_memcmp(dfsan_label label) { if (label == 0) return; void *addr = __builtin_return_address(0); if (label == kInitializingLabel) { // uninitialized label AOUT("WARNING: uninitialized label %u @%p\n", label, addr); if (flags().solve_ub) __send_ubi(label, 0, 0, addr); if (flags().exit_on_memerror) Die(); else return; } dfsan_label_info *info = get_label_info(label); AOUT("tainted memcmp: %d, size: %d\n", label, info->size); if (__pipe_fd < 0) return; uint16_t has_content = 1; // if both operands are symbolic, skip sending the content if ((info->l1 != CONST_LABEL && info->l2 != CONST_LABEL) || info->size == 0) has_content = 0; pipe_msg msg = { .msg_type = memcmp_type, .flags = has_content, .instance_id = __instance_id, .addr = (uptr)addr, .context = __taint_trace_callstack, .label = label, // just in case .result = (uint64_t)info->size }; if (internal_write(__pipe_fd, &msg, sizeof(msg)) < 0) { Die(); } if (!has_content) return; size_t msg_size = sizeof(memcmp_msg) + info->size; memcmp_msg *mmsg = (memcmp_msg*)__builtin_alloca(msg_size); mmsg->label = label; // Copy concrete content: use op1 if l1 is concrete, else op2 void *concrete_ptr = (info->l1 == CONST_LABEL) ? (void*)info->op1.i : (void*)info->op2.i; internal_memcpy(mmsg->content, concrete_ptr, info->size); AOUT("sending memcmp content for label %d, size %u, msg_size=%lu\n", label, info->size, msg_size); // FIXME: assuming single writer so msg will arrive in the same order if (internal_write(__pipe_fd, mmsg, msg_size) < 0) { Die(); } return; } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_memerr(dfsan_label ptr_label, uptr ptr, dfsan_label size_label, uint64_t size, uint16_t flag, void *addr) { if (ptr_label == 0 && size_label == 0) return; if (__pipe_fd < 0) return; uint64_t r = 0; switch(flag) { case F_MEMERR_UAF: r = ptr; break; case F_MEMERR_OLB: r = ptr; break; case F_MEMERR_OUB: r = ptr + size; break; case F_MEMERR_UBI: r = ptr; break; default: return; } pipe_msg msg = { .msg_type = memerr_type, .flags = flag, .instance_id = __instance_id, .addr = (uptr)addr, .context = __taint_trace_callstack, .label = ptr_label, // just in case .result = r }; if (internal_write(__pipe_fd, &msg, sizeof(msg)) < 0) { Die(); } } extern "C" void InitializeSolver() { __instance_id = flags().instance_id; __session_id = flags().session_id; __pipe_fd = flags().pipe_fd; } ================================================ FILE: compiler/CMakeLists.txt ================================================ add_executable(KOClang ko_clang.c) set_target_properties(KOClang PROPERTIES OUTPUT_NAME "ko-clang") add_custom_command(TARGET KOClang POST_BUILD COMMAND ln -sf "ko-clang" "ko-clang++") install (TARGETS KOClang DESTINATION ${SYMSAN_BIN_DIR}) install (FILES ${CMAKE_CURRENT_BINARY_DIR}/ko-clang++ DESTINATION ${SYMSAN_BIN_DIR}) ================================================ FILE: compiler/ko_clang.c ================================================ /* The code is modified from AFL's LLVM mode and Angora. ------------------------------------------------ Written by Laszlo Szekeres and Michal Zalewski Copyright 2015, 2016 Google Inc. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0 */ #define KO_MAIN #include "alloc_inl.h" #include "defs.h" #include "debug.h" #include "version.h" #include #include #include #include #ifndef PATH_MAX #define PATH_MAX 4096 #endif static char *obj_path; /* Path to runtime libraries */ static char *taint_path; /* Path to the taint pass */ static char **cc_params; /* Parameters passed to the real CC */ static u32 cc_par_cnt = 1; /* Param count, including argv0 */ static u8 is_cxx = 0; static u8 use_native_cxx = 0; static u8 use_native_zlib = 1; /* Use system zlib by default */ /* Try to find the executable from PATH */ static char *find_executable_in_path(const char *filename) { char *path = getenv("PATH"); if (path == NULL) { FATAL("Cannot get PATH env"); return NULL; } char *prev = path; char full_path[PATH_MAX]; size_t filename_len = strlen(filename); while (1) { char *colon = strstr(prev, ":"); size_t len = colon ? colon - prev : strlen(prev); if (len + 1 + filename_len + 1 >= PATH_MAX) { WARNF("Path too long: %s", prev); continue; } // Construct the full path memcpy(full_path, prev, len); full_path[len] = '/'; memcpy(full_path + len + 1, filename, filename_len + 1); // Check if the file exists and is executable if (access(full_path, X_OK) == 0) { return ck_strdup(full_path); } if (colon == NULL || *(colon + 1) == '\0') { break; } prev = colon + 1; } return NULL; } /* Try to find the runtime libraries. If that fails, abort. */ static void find_obj(const char *argv0) { char *slash; char path[PATH_MAX]; if (strchr(argv0, '/') == NULL) { char *exec_path = find_executable_in_path(argv0); if (exec_path == NULL) { FATAL("Cannot find the compiler (%s) in PATH", argv0); } if (!realpath(exec_path, path)) { FATAL("Cannot get real path of the compiler (%s): %s", exec_path, strerror(errno)); } ck_free(exec_path); } else { if (!realpath(argv0, path)) { FATAL("Cannot get real path of the compiler (%s): %s", argv0, strerror(errno)); } } slash = strrchr(path, '/'); if (slash) { char *dir; *slash = 0; dir = ck_strdup(path); *slash = '/'; taint_path = alloc_printf("%s/../lib/symsan/TaintPass.so", dir); if (!access(taint_path, R_OK)) { obj_path = alloc_printf("%s/../lib/symsan", dir); } else { FATAL("Unable to find 'TaintPass.so' at %s", path); } ck_free(dir); } } static void check_type(char *name) { if (!strcmp(name, "ko-clang++")) { is_cxx = 1; } } static u8 check_if_assembler(u32 argc, char **argv) { /* Check if a file with an assembler extension ("s" or "S") appears in argv */ while (--argc) { const char *cur = *(++argv); const char *ext = strrchr(cur, '.'); if (ext && (!strcmp(ext + 1, "s") || !strcmp(ext + 1, "S"))) { return 1; } } return 0; } static void add_runtime() { if (getenv("KO_LIBRARY_PATH")) { cc_params[cc_par_cnt++] = alloc_printf("-L%s", getenv("KO_LIBRARY_PATH")); } cc_params[cc_par_cnt++] = "-Wl,--whole-archive"; cc_params[cc_par_cnt++] = alloc_printf("%s/libdfsan_rt-x86_64.a", obj_path); cc_params[cc_par_cnt++] = "-Wl,--no-whole-archive"; cc_params[cc_par_cnt++] = alloc_printf("-Wl,--dynamic-list=%s/libdfsan_rt-x86_64.a.syms", obj_path); cc_params[cc_par_cnt++] = alloc_printf("-Wl,-T%s/taint.ld", obj_path); if (is_cxx && !use_native_cxx) { // cc_params[cc_par_cnt++] = "-Wl,--whole-archive"; cc_params[cc_par_cnt++] = alloc_printf("%s/libc++.a", obj_path); cc_params[cc_par_cnt++] = alloc_printf("%s/libc++abi.a", obj_path); cc_params[cc_par_cnt++] = alloc_printf("%s/libunwind.a", obj_path); // cc_params[cc_par_cnt++] = "-Wl,--no-whole-archive"; } else { cc_params[cc_par_cnt++] = "-lc++"; cc_params[cc_par_cnt++] = "-lc++abi"; cc_params[cc_par_cnt++] = "-l:libunwind.so"; } cc_params[cc_par_cnt++] = "-lrt"; cc_params[cc_par_cnt++] = "-Wl,--no-as-needed"; cc_params[cc_par_cnt++] = "-Wl,--gc-sections"; // if darwin -Wl, -dead_strip cc_params[cc_par_cnt++] = "-ldl"; cc_params[cc_par_cnt++] = "-lpthread"; cc_params[cc_par_cnt++] = "-lm"; if (use_native_zlib) { cc_params[cc_par_cnt++] = "-lz"; } if (getenv("KO_USE_Z3")) { cc_params[cc_par_cnt++] = "-Wl,--whole-archive"; cc_params[cc_par_cnt++] = alloc_printf("%s/libZ3Solver.a", obj_path); cc_params[cc_par_cnt++] = "-Wl,--no-whole-archive"; cc_params[cc_par_cnt++] = "-L/usr/local/lib"; cc_params[cc_par_cnt++] = "-lz3"; cc_params[cc_par_cnt++] = "-Wl,-rpath,/usr/local/lib"; } if (getenv("KO_USE_FASTGEN")) { cc_params[cc_par_cnt++] = "-Wl,--whole-archive"; cc_params[cc_par_cnt++] = alloc_printf("%s/libFastgen.a", obj_path); cc_params[cc_par_cnt++] = "-Wl,--no-whole-archive"; } } static void add_taint_pass() { cc_params[cc_par_cnt++] = "-fexperimental-new-pass-manager"; cc_params[cc_par_cnt++] = alloc_printf("-fplugin=%s", taint_path); // to enable options cc_params[cc_par_cnt++] = alloc_printf("-fpass-plugin=%s", taint_path); cc_params[cc_par_cnt++] = "-mllvm"; cc_params[cc_par_cnt++] = alloc_printf("-taint-abilist=%s/dfsan_abilist.txt", obj_path); if (use_native_zlib) { cc_params[cc_par_cnt++] = "-mllvm"; cc_params[cc_par_cnt++] = alloc_printf("-taint-abilist=%s/zlib_abilist.txt", obj_path); } if (getenv("KO_TRACE_FP")) { cc_params[cc_par_cnt++] = "-mllvm"; cc_params[cc_par_cnt++] = "-taint-trace-float-pointer"; } if (getenv("KO_NO_TRACE_BOUND")) { cc_params[cc_par_cnt++] = "-mllvm"; cc_params[cc_par_cnt++] = "-taint-trace-bound=false"; } if (getenv("KO_SOLVE_UB")) { cc_params[cc_par_cnt++] = "-mllvm"; cc_params[cc_par_cnt++] = "-taint-solve-ub=true"; } if (is_cxx && use_native_cxx) { cc_params[cc_par_cnt++] = "-mllvm"; cc_params[cc_par_cnt++] = alloc_printf("-taint-abilist=%s/libc++_abilist.txt", obj_path); } } static void edit_params(u32 argc, char **argv) { u8 fortify_set = 0, asan_set = 0, x_set = 0, maybe_linking = 1, bit_mode = 0; u8 maybe_assembler = 0; char *name; cc_params = ck_alloc((argc + 128) * sizeof(char *)); name = strrchr(argv[0], '/'); if (!name) name = argv[0]; else name++; check_type(name); if (is_cxx) { char *alt_cxx = getenv("KO_CXX"); cc_params[0] = alt_cxx ? alt_cxx : "clang++"; } else { char *alt_cc = getenv("KO_CC"); cc_params[0] = alt_cc ? alt_cc : "clang"; } maybe_assembler = check_if_assembler(argc, argv); use_native_cxx = getenv("KO_USE_NATIVE_LIBCXX") ? 1 : 0; use_native_zlib = getenv("KO_NO_NATIVE_ZLIB") ? 0 : 1; /* Detect stray -v calls from ./configure scripts. */ if (argc == 1 && !strcmp(argv[1], "-v")) maybe_linking = 0; while (--argc) { char *cur = *(++argv); // FIXME if (!strcmp(cur, "-O1") || !strcmp(cur, "-O2") || !strcmp(cur, "-O3")) { //continue; } if (!strcmp(cur, "-m32")) bit_mode = 32; if (!strcmp(cur, "-m64")) bit_mode = 64; if (!strcmp(cur, "-x")) x_set = 1; if (!strcmp(cur, "-c") || !strcmp(cur, "-S") || !strcmp(cur, "-E")) maybe_linking = 0; if (!strncmp(cur, "-fsanitize=", strlen("-fsanitize="))) { continue; // doesn't work together } if (!use_native_zlib && !strcmp(cur, "-lz")) continue; // ignore -lz if we are using our own zlib if (strstr(cur, "FORTIFY_SOURCE")) fortify_set = 1; if (!strcmp(cur, "-shared")) maybe_linking = 0; if (!strcmp(cur, "-Wl,-z,defs") || !strcmp(cur, "-Wl,--no-undefined")) continue; if (strstr(cur, "-stdlib=") == cur) { // XXX: use native if the target prefers stdlibc++? continue; } if (!strcmp(cur, "-lc++") || !strcmp(cur, "-lc++abi") || !strcmp(cur, "-lunwind") || strstr(cur, "-l:libc++.so") == cur || strstr(cur, "-l:libc++abi.so") == cur || strstr(cur, "-l:libunwind.so") == cur) { // skip libc++, libc++abi, and libunwind continue; } if (strstr(cur, "libSymsanProxy.o")) { char* last = *(argv - 1); if (last) { if (!strcmp(last, "-I")) { // remove the -I cc_params[cc_par_cnt - 1] = cur; continue; } if (!strcmp(last, "-L")) { // remove the -L cc_params[cc_par_cnt - 1] = cur; continue; } } } cc_params[cc_par_cnt++] = cur; } if (getenv("KO_CONFIG")) { cc_params[cc_par_cnt] = NULL; return; } if (!maybe_assembler) { add_taint_pass(); } cc_params[cc_par_cnt++] = "-pie"; cc_params[cc_par_cnt++] = "-fpic"; cc_params[cc_par_cnt++] = "-Qunused-arguments"; cc_params[cc_par_cnt++] = "-fno-vectorize"; cc_params[cc_par_cnt++] = "-fno-slp-vectorize"; #if 0 cc_params[cc_par_cnt++] = "-mno-mmx"; cc_params[cc_par_cnt++] = "-mno-sse"; cc_params[cc_par_cnt++] = "-mno-sse2"; cc_params[cc_par_cnt++] = "-mno-avx"; cc_params[cc_par_cnt++] = "-mno-sse3"; cc_params[cc_par_cnt++] = "-mno-sse4.1"; cc_params[cc_par_cnt++] = "-mno-sse4.2"; cc_params[cc_par_cnt++] = "-mno-ssse3"; cc_params[cc_par_cnt++] = "-mno-avx2"; cc_params[cc_par_cnt++] = "-mno-avx512f"; cc_params[cc_par_cnt++] = "-mno-avx512bw"; cc_params[cc_par_cnt++] = "-mno-avx512dq"; cc_params[cc_par_cnt++] = "-mno-avx512vl"; #endif if (getenv("KO_HARDEN")) { cc_params[cc_par_cnt++] = "-fstack-protector-all"; if (!fortify_set) cc_params[cc_par_cnt++] = "-D_FORTIFY_SOURCE=2"; } if (!getenv("KO_DONT_OPTIMIZE")) { cc_params[cc_par_cnt++] = "-g"; cc_params[cc_par_cnt++] = "-O3"; cc_params[cc_par_cnt++] = "-funroll-loops"; } if (is_cxx && !use_native_cxx) { // FIXME: or use the same header // cc_params[cc_par_cnt++] = alloc_printf("-I%s/../include/c++/v1", obj_path); cc_params[cc_par_cnt++] = "-stdlib=libc++"; } if (maybe_linking) { if (x_set) { cc_params[cc_par_cnt++] = "-x"; cc_params[cc_par_cnt++] = "none"; } add_runtime(); switch (bit_mode) { case 0: break; case 32: /* if (access(cc_params[cc_par_cnt - 1], R_OK)) */ FATAL("-m32 is not supported by your compiler"); break; case 64: /* if (access(cc_params[cc_par_cnt - 1], R_OK)) */ // FATAL("-m64 is not supported by your compiler"); break; } } cc_params[cc_par_cnt] = NULL; } /* Main entry point */ int main(int argc, char **argv) { if (argc < 2) { SAYF("\n" "This is a helper application for Kirenenko. It serves as a drop-in " "replacement\n" "for clang, letting you recompile third-party code with the required " "runtime\n" "instrumentation. A common use pattern would be one of the " "following:\n\n" " CC=%s/ko-clang ./configure\n" " CXX=%s/ko-clang++ ./configure\n\n" "You can specify custom next-stage toolchain via KO_CC and KO_CXX." "You can set (e.g., export) KO_CONFIG=1 to avoid problems during " "configure.\n" "Setting\n" "KO_HARDEN enables hardening optimizations in the compiled " "code.\n\n", "xx", "xx"); exit(1); } find_obj(argv[0]); edit_params(argc, argv); for (int i = 0; i < cc_par_cnt; i++) { printf("%s ", cc_params[i]); } printf("\n"); execvp(cc_params[0], (char **)cc_params); FATAL("Oops, failed to execute '%s' - check your PATH", cc_params[0]); return 0; } ================================================ FILE: driver/CMakeLists.txt ================================================ set(CMAKE_POSITION_INDEPENDENT_CODE ON) set(CMAKE_CXX_STANDARD 14) ## launcher lib add_subdirectory(launcher) ## simple driver for testing out-of-process solving add_executable(FGTest fgtest.cpp) set_target_properties(FGTest PROPERTIES OUTPUT_NAME "fgtest") target_include_directories(FGTest PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../runtime ) target_link_libraries(FGTest PRIVATE launcher z3parser ${Z3_LIBRARY} rt ) install (TARGETS FGTest DESTINATION ${SYMSAN_BIN_DIR}) if (DEFINED AFLPP_PATH) add_subdirectory(aflpp) endif() install (CODE "MESSAGE(STATUS \"Build & Install: libSymsanProxy.o\")") install (CODE "execute_process(COMMAND \ ${CMAKE_INSTALL_PREFIX}/${SYMSAN_BIN_DIR}/ko-clang \ -c ${CMAKE_CURRENT_SOURCE_DIR}/harness-proxy.c \ -o ${CMAKE_INSTALL_PREFIX}/${SYMSAN_LIB_DIR}/libSymsanProxy.o)") ================================================ FILE: driver/aflpp/CMakeLists.txt ================================================ ## custom_mutation for AFL++ project(SymSanMutator C CXX) set(CMAKE_POSITION_INDEPENDENT_CODE ON) set(CMAKE_CXX_STANDARD 17) # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -g -mcx16 -march=native -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free") if (ASAN_BUILD) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address") endif() if (NOT IS_DIRECTORY "${AFLPP_PATH}/include") message(FATAL_ERROR "Invalid AFL++ directory path! ${AFLPP_PATH}") endif() add_library(SymSanMutator SHARED symsan.cpp ) target_include_directories(SymSanMutator PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../runtime ${AFLPP_PATH}/include ) target_link_libraries(SymSanMutator launcher rgd-parser rgd-solver ) if (ASAN_BUILD) target_link_libraries(SymSanMutator ${LLVM_BINARY_DIR}/lib/clang/12.0.1/lib/linux/libclang_rt.asan-x86_64.a ) endif() install (TARGETS SymSanMutator DESTINATION ${SYMSAN_BIN_DIR}) ================================================ FILE: driver/aflpp/README.md ================================================ # A AFL++ plugin for using SYMSAN as a custom mutator libafl should be a better option but due to my familarity with C++, this is a temporary option. ## HowTo A quick guide to how to use the plugin: ### Compilation Right now I only have tested on Ubuntu 20.04 and 22.04. First, install dependencies: ``` apt-get update apt-get install -y lsb-release wget software-properties-common gnupg wget https://apt.llvm.org/llvm.sh && chmod +x llvm.sh && ./llvm.sh 12 apt-get install -y cmake libc++-12-dev libc++abi-12-dev libunwind-12 python3-minimal python-is-python3 zlib1g-dev git gdb joe apt-get install -y libz3-dev libgoogle-perftools-dev ``` Next, download and build AFL++: ``` git clone --depth=1 https://github.com/AFLplusplus/AFLplusplus /workdir/aflpp ENV LLVM_CONFIG=llvm-config-14 cd /workdir/aflpp && CC=clang-14 CXX=clang++-14 make source-only && make install ``` Next, download symsan and build ``` git clone https://github.com/R-Fuzz/symsan /workdir/symsan cd symsan/ && mkdir -p build && \ cd build && CC=clang-14 CXX=clang++-14 cmake -DAFLPP_PATH=/workdir/aflpp ../ && \ make -j && make install ``` ### Build target binaries You need to compile two binaries: one for normal fuzzing and one for symbolic tracing For the normal fuzzing binary, you can set `AFL_LLVM_CMPLOG=0` to disable `cmplog` as the plugin does a similar job. Please refer to the AFL++ manual for building options. For the symbolic tracing binary, set the following env options * `KO_CC=clang-14`: use clang-14 as the C compiler, because SymSan is compiled as a LLVM-12 pass * `KO_CXX=clang++-14`: using clang++-14 as the C++ compiler * `KO_USE_FASTGEN=1`: using the out-of-process solving mode (i.e., decoupled tracing and solving) * `KO_DONT_OPTIMIZE=1` (optional): keep the original optimization level, otherwise override with `-O3` * `KO_NO_NATIVE_ZLIB` (optional): if you're using instrumented libz * `KO_USE_NATIVE_LIBCXX` (optional): if you want to use the native, *uninstrumented* standard C++ lib, the default option uses the instrumented `libc++` and `libc++-abi`. To build the target, set `CC=/path/to/symsan/bin/ko-clang` and `CXX=/path/to/symsan/bin/ko-clang++`. If the configuration fails, you can set `KO_CONFIG=1`, and unset it after configuration. ### Fuzz After the two binaries are built, use AFL++ to fuzz it, use the following env options to load the plugin and control its behavior: * `AFL_CUSTOM_MUTATOR_LIBRARY=/path/to/symsan/bin/libSymSanMutator.so`: load the plugin * `SYMSAN_TARGET=/path/to/symsan-instrumented-binary`: symbolic tracing binary * `AFL_DISABLE_TRIM=1` (optional): for some targets (e.g., the `mini` test case), you may want to disable trim * `AFL_CUSTOM_MUTATOR_ONLY=1` (optional): if you only want to test the plugin * `SYMSAN_OUTPUT_DIR=/none/default/dir` (optional): a different directory to store temporary outputs from SymSan * `SYMSAN_USE_JIGSAW=1` (optional): use JIGSAW as the solver * `SYMSAN_USE_Z3=1` (optional): use Z3 as the solver * `SYMSAN_USE_NESTED=1` (optional): consider nested branches when constructing a solving task ## Some high-level design The custom mutator works in two main steps: 1. In the interface function `afl_custom_fuzz_count`, the plugin spawns a symsan-instrumented binary to collect the symbolic traces (i.e., the tracing stage in libafl). For each event it wants to handle, it constructs a *solving task*. 2. In the interface function `afl_custom_fuzz`, the plugin fetches a *solving task*, solves it, and generate a new input (i.e., the mutation stage in libafl). The newly generated input is then evaluated with the main fuzzing binary. If the input is saved, the task is considered as successfully solved. ## Extensions One main motivation to move to libafl and afl++ custom mutator is to make the concolic execution stage more extensible (than in fastgen). Following are some interfaces that can be customized: * `rgd::CovManager` is in charge of determine whether an event from symsan should be used to construct a solving task. The default one uses branch coverage (similar to sancov `trace-pc-guard`) to filter events. * `rgd::TaskManager` is in charge of scheduling *solving tasks*. The default one is a simple FIFO queue. * `rgd::Solver` is in charge of solving a solving task. Right now there are three solvers, which works in a layered manner (i2s->jigsaw->z3): if a task is solved by an earlier solver, it will skip the next solver; otherwise the next solver is invoked. * The default one is a simple I2S solver, which uses tracing results to map input bytes to comparison operands and generate a solution based on potential [input-to-state correspondence](https://www.ndss-symposium.org/ndss-paper/redqueen-fuzzing-with-input-to-state-correspondence/). * JIGSAW, which is our [JIT-based constraint solver](https://github.com/R-Fuzz/jigsaw). * Z3 ================================================ FILE: driver/aflpp/rgd.proto ================================================ syntax = "proto3"; package rgd; // AST node for symbolic expressions message AstNode { uint32 kind = 1; uint32 boolvalue = 2; //used by bool expr uint32 bits = 3; string value = 4; //used by constant expr repeated AstNode children = 5; string name = 6; //used for debugging uint32 index = 7; //used by read expr for index and extract expr uint32 label = 8; //for expression dedup uint32 hash = 9; //for node dedup uint32 direction = 10; uint32 sessionid = 11; uint32 full = 12; } ================================================ FILE: driver/aflpp/symsan.cpp ================================================ /* a custom mutator for AFL++ (c) 2023 - 2024 by Chengyu Song License: Apache 2.0 */ #include "dfsan/dfsan.h" #include "ast.h" #include "task.h" #include "solver.h" #include "cov.h" #include "task_mgr.h" extern "C" { #include "afl-fuzz.h" #include "launch.h" } #include "parse-rgd.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace __dfsan; #ifndef DEBUG #define DEBUG 0 #endif #if !DEBUG #undef DEBUGF #define DEBUGF(_str...) do { } while (0) #endif #define PRINT_STATS 0 #define MAX_AST_SIZE 200 #define MIN_TIMEOUT 50U #define MAX_LOCAL_BRANCH_COUNTER 128 static bool NestedSolving = false; static int TraceBounds = 0; static int ExitOnMemError = 1; // default is exit on memory error static int SolveUB = 0; static int ForceStdin = 0; static bool SaveSolved = false; #undef alloc_printf #define alloc_printf(_str...) ({ \ char* _tmp; \ s32 _len = snprintf(NULL, 0, _str); \ if (_len < 0) FATAL("Whoa, snprintf() fails?!"); \ _tmp = (char*)ck_alloc(_len + 1); \ snprintf((char*)_tmp, _len + 1, _str); \ _tmp; \ }) using solver_t = std::shared_ptr; using branch_ctx_t = std::shared_ptr; enum mutation_state_t { MUTATION_INVALID, MUTATION_IN_VALIDATION, MUTATION_VALIDATED, }; struct my_mutator_t { my_mutator_t() = delete; my_mutator_t(const afl_state_t *afl, rgd::TaskManager* tmgr, rgd::CovManager* cmgr) : afl(afl), out_dir(NULL), out_file(NULL), symsan_bin(NULL), argv(NULL), out_fd(-1), cur_queue_entry(NULL), cur_mutation_state(MUTATION_INVALID), output_buf(NULL), cur_task(nullptr), cur_solver_index(-1), task_mgr(tmgr), cov_mgr(cmgr) {} ~my_mutator_t() { if (out_fd >= 0) close(out_fd); ck_free(out_dir); ck_free(out_file); ck_free(output_buf); ck_free(argv); delete task_mgr; delete cov_mgr; } const afl_state_t *afl; char *out_dir; char *out_file; char *symsan_bin; char **argv; int out_fd; u8* cur_queue_entry; int cur_mutation_state; u8* output_buf; int log_fd; std::unordered_set fuzzed_inputs; rgd::TaskManager* task_mgr; rgd::CovManager* cov_mgr; rgd::RGDAstParser* parser; std::vector solvers; // XXX: well, we have to keep track of solving states rgd::task_t cur_task; size_t cur_solver_index; }; // FIXME: find another way to make the union table hash work static dfsan_label_info *__dfsan_label_info; static const size_t MAX_LABEL = uniontable_size / sizeof(dfsan_label_info); dfsan_label_info* __dfsan::get_label_info(dfsan_label label) { if (unlikely(label >= MAX_LABEL)) { throw std::out_of_range("label too large " + std::to_string(label)); } return &__dfsan_label_info[label]; } // FIXME: local filter? static std::unordered_map local_counter; static std::unordered_set local_index_filter; // staticstics static uint64_t total_branches = 0; static uint64_t branches_to_solve = 0; static uint64_t total_tasks = 0; static std::map task_size_dist; static uint64_t solved_tasks = 0; static uint64_t solved_branches = 0; static void reset_global_caches(size_t buf_size) { local_counter.clear(); local_index_filter.clear(); } static void handle_cond(pipe_msg &msg, my_mutator_t *my_mutator) { if (unlikely(msg.label == 0)) { return; } else if (unlikely(msg.label == kInitializingLabel)) { WARNF("UBI branch cond @%p\n", (void*)msg.addr); return; } total_branches += 1; // apply a local (per input) branch filter auto &lc = local_counter[msg.id]; if (lc > MAX_LOCAL_BRANCH_COUNTER) { return; } else { lc += 1; } // prase flags bool always_solve = (msg.flags & F_ADD_CONS) == 0; bool loop_latch = (msg.flags & F_LOOP_LATCH) != 0; bool loop_exit = (msg.flags & F_LOOP_EXIT) != 0; const branch_ctx_t ctx = my_mutator->cov_mgr->add_branch((void*)msg.addr, msg.id, msg.result != 0, msg.context, loop_latch, loop_exit); branch_ctx_t neg_ctx = std::make_shared(); *neg_ctx = *ctx; neg_ctx->direction = !ctx->direction; if (my_mutator->cov_mgr->is_branch_interesting(neg_ctx) || always_solve) { // parse the uniont table AST to solving tasks std::vector tasks; if (my_mutator->parser->parse_cond(msg.label, ctx->direction, msg.flags & F_ADD_CONS, tasks) != 0) { WARNF("Failed to parse the condition %u, from input %s\n", msg.label, my_mutator->cur_queue_entry); // symsan_terminate(); return; } // add the tasks to the task manager for (auto const& task_id : tasks) { auto task = my_mutator->parser->retrieve_task(task_id); my_mutator->task_mgr->add_task(neg_ctx, task); #if PRINT_STATS task_size_dist[task->constraints.size()] += 1; #endif } total_tasks += tasks.size(); branches_to_solve += 1; } } static void handle_gep(gep_msg &gmsg, pipe_msg &msg, my_mutator_t *my_mutator) { // msg.label === gmsg.index_label if (unlikely(msg.label == 0)) { return; } else if (unlikely(msg.label == kInitializingLabel)) { WARNF("UBI array index @%p\n", (void*)msg.addr); return; } // apply a local (per input) index filter if (!local_index_filter.insert(msg.label).second) { return; } // parse the uniont table AST to solving tasks std::vector tasks; if (my_mutator->parser->parse_gep(gmsg.ptr_label, gmsg.ptr, gmsg.index_label, gmsg.index, gmsg.num_elems, gmsg.elem_size, gmsg.current_offset, false, tasks) != 0) { WARNF("Failed to parse symbolic index %u, from input %s\n", gmsg.index_label, my_mutator->cur_queue_entry); // symsan_terminate(); return; } // add the tasks to the task manager, with a dummy context branch_ctx_t ctx = std::make_shared(); ctx->addr = (void*)msg.addr; ctx->direction = true; for (auto const& task_id : tasks) { auto task = my_mutator->parser->retrieve_task(task_id); my_mutator->task_mgr->add_task(ctx, task); #if PRINT_STATS task_size_dist[task->constraints.size()] += 1; #endif } total_tasks += tasks.size(); } /// no splice input extern "C" void afl_custom_splice_optout(my_mutator_t *data) { (void)(data); } /// @brief init the custom mutator /// @param afl aflpp state /// @param seed not used /// @return custom mutator state extern "C" my_mutator_t *afl_custom_init(afl_state *afl, unsigned int seed) { (void)(seed); struct stat st; rgd::TaskManager *tmgr = new rgd::FIFOTaskManager(); rgd::CovManager *cmgr = new rgd::EdgeCovManager(); my_mutator_t *data = new my_mutator_t(afl, tmgr, cmgr); if (!data) { FATAL("afl_custom_init alloc"); return NULL; } // always use the simpler i2s solver data->solvers.emplace_back(std::make_shared()); if (getenv("SYMSAN_USE_JIGSAW")) data->solvers.emplace_back(std::make_shared()); if (getenv("SYMSAN_USE_Z3")) data->solvers.emplace_back(std::make_shared()); // make nested solving optional too if (getenv("SYMSAN_USE_NESTED")) { NestedSolving = true; } // enable trace bounds? if (getenv("SYMSAN_TRACE_BOUNDS")) { TraceBounds = 1; } // disable exit on memory error if (getenv("SYMSAN_DONT_EXIT_ON_MEMERROR")) { ExitOnMemError = 0; } if (getenv("SYMSAN_SOLVE_UB")) { TraceBounds = 1; // solve undefined depends on trace bounds SolveUB = 1; } // XXX: force stdin? ugly hack for aixcc if (getenv("SYMSAN_FORCE_STDIN")) { ForceStdin = 1; } // enable saving solved tasks if (getenv("SYMSAN_SAVE_SOLVED")) { SaveSolved = true; } if (!(data->symsan_bin = getenv("SYMSAN_TARGET"))) { FATAL( "SYMSAN_TARGET not defined, this should point to the full path of the " "symsan compiled binary."); } if (!(data->out_dir = getenv("SYMSAN_OUTPUT_DIR"))) { data->out_dir = alloc_printf("%s/symsan", afl->out_dir); } if (stat(data->out_dir, &st) && mkdir(data->out_dir, 0755)) { PFATAL("Could not create the output directory %s", data->out_dir); } // setup output file char *out_file; if (afl->file_extension) { out_file = alloc_printf("%s/.cur_input.%s", data->out_dir, afl->file_extension); } else { out_file = alloc_printf("%s/.cur_input", data->out_dir); } if (data->out_dir[0] == '/') { data->out_file = out_file; } else { char cwd[PATH_MAX]; if (getcwd(cwd, (size_t)sizeof(cwd)) == NULL) { PFATAL("getcwd() failed"); } data->out_file = alloc_printf("%s/%s", cwd, out_file); ck_free(out_file); } // create the output file data->out_fd = open(data->out_file, O_RDWR | O_CREAT | O_TRUNC, 0644); if (data->out_fd < 0) { PFATAL("Failed to create output file %s: %s\n", data->out_file, strerror(errno)); } // setup symsan launcher __dfsan_label_info = (dfsan_label_info *)symsan_init(data->symsan_bin, uniontable_size); if (__dfsan_label_info == (void *)-1) { FATAL("Failed to init symsan launcher: %s\n", strerror(errno)); } // setup the parser data->parser = new rgd::RGDAstParser(__dfsan_label_info, uniontable_size, NestedSolving, MAX_AST_SIZE); if (!data->parser) { FATAL("Failed to create parser\n"); } // allocate output buffer data->output_buf = (u8 *)malloc(MAX_FILE+1); if (!data->output_buf) { FATAL("Failed to alloc output buffer\n"); } #if PRINT_STATS char *log_f = getenv("SYMSAN_LOG_FILE"); if (log_f) { data->log_fd = open(log_f, O_RDWR | O_CREAT | O_TRUNC, 0644); if (data->log_fd < 0) { PFATAL("Failed to create log file: %s\n", strerror(errno)); } } else { data->log_fd = 2; // stderr by default } #endif return data; } extern "C" void afl_custom_deinit(my_mutator_t *data) { symsan_destroy(); delete data; } /// @brief the trace stage for symsan /// @param data the custom mutator state /// @param buf input buffer /// @param buf_size /// @return the number of solving tasks extern "C" u32 afl_custom_fuzz_count(my_mutator_t *data, const u8 *buf, size_t buf_size) { // check the input id to see if it's been run before // we don't use the afl_custom_queue_new_entry() because we may not // want to solve all the tasks u32 input_id = data->afl->queue_cur->id; u32 timeout = std::min(MIN_TIMEOUT, data->afl->fsrv.exec_tmout); if (data->fuzzed_inputs.find(input_id) != data->fuzzed_inputs.end()) { return 0; } data->fuzzed_inputs.insert(input_id); // record the name of the current queue entry data->cur_queue_entry = data->afl->queue_cur->fname; DEBUGF("Fuzzing %s\n", data->cur_queue_entry); // FIXME: should we use the afl->queue_cur->fname instead? // write the buf to the file lseek(data->out_fd, 0, SEEK_SET); ck_write(data->out_fd, buf, buf_size, data->out_file); fsync(data->out_fd); if (ftruncate(data->out_fd, buf_size)) { WARNF("Failed to truncate output file: %s\n", strerror(errno)); return 0; } // setup argv in case of initialized if (unlikely(!data->argv)) { int argc = 0; while (data->afl->argv[argc]) { argc++; } data->argv = (char **)calloc(argc + 1, sizeof(char *)); if (!data->argv) { FATAL("Failed to alloc argv\n"); } for (int i = 0; i < argc; i++) { if (strstr(data->afl->argv[i], (char*)data->afl->tmp_dir)) { DEBUGF("Replacing %s with %s\n", data->afl->argv[i], data->out_file); data->argv[i] = data->out_file; } else { data->argv[i] = data->afl->argv[i]; } } data->argv[argc] = NULL; // setup symsan launcher symsan_set_input(data->afl->fsrv.use_stdin ? "stdin" : data->out_file); symsan_set_args(argc, data->argv); symsan_set_debug(DEBUG); symsan_set_bounds_check(TraceBounds); symsan_set_exit_on_memerror(ExitOnMemError); symsan_set_solve_ub(SolveUB); symsan_set_force_stdin(ForceStdin); } // launch the symsan child process int ret = symsan_run(data->out_fd); if (ret < 0) { WARNF("Failed to start symsan bin: %s\n", strerror(errno)); return 0; } else if (ret > 0) { WARNF("symsan_run failed %d\n", ret); return 0; } pipe_msg msg; gep_msg gmsg; memcmp_msg *mmsg; dfsan_label_info *info; size_t msg_size; u32 num_tasks = 0; u32 num_msgs = 0; bool timedout = false; struct timeval start, end; gettimeofday(&start, NULL); // clear all caches std::vector inputs; inputs.push_back({buf, buf_size}); data->parser->restart(inputs); reset_global_caches(buf_size); while (symsan_read_event(&msg, sizeof(msg), timeout) == sizeof(msg)) { // create solving tasks switch (msg.msg_type) { // conditional branch case cond_type: handle_cond(msg, data); break; case gep_type: if (symsan_read_event(&gmsg, sizeof(gmsg), 0) != sizeof(gmsg)) { WARNF("Failed to receive gep msg: %s\n", strerror(errno)); break; } // double check if (msg.label != gmsg.index_label) { WARNF("Incorrect gep msg: %d vs %d\n", msg.label, gmsg.index_label); break; } handle_gep(gmsg, msg, data); break; case memcmp_type: if (msg.label == 0 || msg.label >= MAX_LABEL) { WARNF("Invalid memcmp label: %d\n", msg.label); break; } info = get_label_info(msg.label); // if both operands are symbolic, no content to be read if (info->l1 != CONST_LABEL && info->l2 != CONST_LABEL) break; // flags = 0 means both operands are symbolic thus no content to read // if (!msg.flags) // break; msg_size = sizeof(memcmp_msg) + msg.result; mmsg = (memcmp_msg*)malloc(msg_size); if (symsan_read_event(mmsg, msg_size, 0) != msg_size) { WARNF("Failed to receive memcmp msg: %s\n", strerror(errno)); free(mmsg); break; } // double check if (msg.label != mmsg->label) { WARNF("Incorrect memcmp msg: %d vs %d\n", msg.label, mmsg->label); free(mmsg); break; } // save the content data->parser->record_memcmp(msg.label, mmsg->content, msg.result); free(mmsg); break; case fsize_type: break; case memerr_type: WARNF("Memory error detected @%p, type = %d\n", (void*)msg.addr, msg.flags); break; default: break; } // naive deadloop detection num_msgs += 1; if (unlikely((num_msgs & 0xffffe000) != 0)) { gettimeofday(&end, NULL); if ((end.tv_sec - start.tv_sec) * 10 > timeout) { // allow 100x slowdown, sec * 1000 > ms * 100 WARNF("Possible deadloop, break\n"); timedout = true; break; } } } if (timedout) { // kill the symsan process symsan_terminate(); } // reinit solving state data->cur_task = nullptr; size_t max_stages = data->solvers.size(); // to be conservative, we return the maximum number of possible mutations return (u32)(data->task_mgr->get_num_tasks() * max_stages); } static void print_stats(my_mutator_t *data) { dprintf(data->log_fd, "Total branches: %zu,\n"\ "Total tasks: %zu,\n"\ "Solved tasks: %zu,\n"\ "Solved branches: %zu\n", total_branches, total_tasks, solved_tasks, solved_branches); dprintf(data->log_fd, "Task size distribution:\n"); for (auto const& kv : task_size_dist) { dprintf(data->log_fd, "\t %zu: %zu\n", kv.first, kv.second); } for (auto &solver : data->solvers) { solver->print_stats(data->log_fd); } } extern "C" size_t afl_custom_fuzz(my_mutator_t *data, uint8_t *buf, size_t buf_size, u8 **out_buf, uint8_t *add_buf, size_t add_buf_size, size_t max_size) { (void)(add_buf); (void)(add_buf_size); (void)(max_size); if (buf_size > MAX_FILE) { *out_buf = buf; return 0; } // try to get a task if we don't already have one // or if we've find a valid solution from the previous mutation if (!data->cur_task || data->cur_mutation_state == MUTATION_VALIDATED) { data->cur_task = data->task_mgr->get_next_task(); if (!data->cur_task) { DEBUGF("No more tasks to solve\n"); data->cur_mutation_state = MUTATION_INVALID; *out_buf = buf; #if PRINT_STATS print_stats(data); #endif return 0; } // reset the solver and state data->cur_solver_index = 0; data->cur_mutation_state = MUTATION_INVALID; } // check the previous mutation state if (data->cur_mutation_state == MUTATION_IN_VALIDATION) { // oops, not solve, move on to next solver data->cur_solver_index++; if (data->cur_solver_index >= data->solvers.size()) { // if reached the max solver, move on to the next task data->cur_task = data->task_mgr->get_next_task(); if (!data->cur_task) { DEBUGF("No more tasks to solve\n"); data->cur_mutation_state = MUTATION_INVALID; *out_buf = buf; #if PRINT_STATS print_stats(data); #endif return 0; } data->cur_solver_index = 0; // reset solver index } } // default return values size_t new_buf_size = 0; *out_buf = buf; auto &solver = data->solvers[data->cur_solver_index]; auto ret = solver->solve(data->cur_task, buf, buf_size, data->output_buf, new_buf_size); if (likely(ret == rgd::SOLVER_SAT)) { DEBUGF("task solved\n"); data->cur_mutation_state = MUTATION_IN_VALIDATION; *out_buf = data->output_buf; if (SaveSolved) { // save the solved task char *solved_file = alloc_printf("%s/id_%zu", data->out_dir, solved_tasks); if (solved_file != NULL) { int fd = open(solved_file, O_RDWR | O_CREAT | O_TRUNC, 0644); if (fd < 0) { WARNF("Failed to create solved file %s: %s\n", solved_file, strerror(errno)); } else { lseek(fd, 0, SEEK_SET); ck_write(fd, data->output_buf, new_buf_size, solved_file); close(fd); } free(solved_file); } } solved_tasks += 1; } else if (ret == rgd::SOLVER_TIMEOUT) { // if not solved, move on to next stage data->cur_mutation_state = MUTATION_IN_VALIDATION; } else if (ret == rgd::SOLVER_UNSAT) { // at any stage if the task is deemed unsolvable, just skip it DEBUGF("task not solvable\n"); data->cur_task->skip_next = true; data->cur_task = nullptr; } else { WARNF("Unknown solver return value %d\n", ret); *out_buf = NULL; new_buf_size = 0; } return new_buf_size; } // FIXME: use new queue entry as feedback to see if the last mutation is successful extern "C" uint8_t afl_custom_queue_new_entry(my_mutator_t * data, const uint8_t *filename_new_queue, const uint8_t *filename_orig_queue) { // if we're in validation state and the current queue entry is the same as // mark the constraints as solved DEBUGF("new queue entry: %s\n", filename_new_queue); if (data->cur_queue_entry == filename_orig_queue && data->cur_mutation_state == MUTATION_IN_VALIDATION) { data->cur_mutation_state = MUTATION_VALIDATED; if (data->cur_task) { data->cur_task->skip_next = true; solved_branches += 1; } } return 0; } ================================================ FILE: driver/fgtest.cpp ================================================ #include "defs.h" #include "debug.h" #include "version.h" #include "dfsan/dfsan.h" extern "C" { #include "launch.h" } #include "parse-z3.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace __dfsan; #define OPTIMISTIC 1 #undef AOUT # define AOUT(...) \ do { \ printf(__VA_ARGS__); \ } while(false) // for input static char *input_buf; static size_t input_size; // for output static const char* __output_dir = "."; static uint32_t __instance_id = 0; static uint32_t __session_id = 0; static uint32_t __current_index = 0; static int __enum_gep = 0; // GEP enumeration enabled by default static z3::context __z3_context; // z3parser symsan::Z3ParserSolver *__z3_parser = nullptr; static void generate_input(symsan::Z3ParserSolver::solution_t &solutions) { using op_t = symsan::Z3ParserSolver::solution_op_t; // Build the new input in memory to handle INSERT/DELETE properly std::vector new_input(input_buf, input_buf + input_size); // Sort solutions by offset in descending order so INSERT/DELETE don't // invalidate subsequent offsets std::vector order(solutions.size()); for (size_t i = 0; i < order.size(); ++i) order[i] = i; std::sort(order.begin(), order.end(), [&solutions](size_t a, size_t b) { return solutions[a].offset > solutions[b].offset; }); for (size_t idx : order) { const auto& sol = solutions[idx]; switch (sol.op) { case op_t::SET: if (sol.offset < new_input.size()) { AOUT("SET offset %d = %x\n", sol.offset, sol.val); new_input[sol.offset] = sol.val; } break; case op_t::INSERT: if (sol.offset <= new_input.size()) { AOUT("INSERT %zu bytes at offset %d\n", sol.data.size(), sol.offset); new_input.insert(new_input.begin() + sol.offset, sol.data.begin(), sol.data.end()); } break; case op_t::DELETE: if (sol.offset < new_input.size()) { size_t del_len = std::min((size_t)sol.len, new_input.size() - sol.offset); AOUT("DELETE %zu bytes at offset %d\n", del_len, sol.offset); new_input.erase(new_input.begin() + sol.offset, new_input.begin() + sol.offset + del_len); } break; } } // Write the new input to file char path[PATH_MAX]; snprintf(path, PATH_MAX, "%s/id-%d-%d-%d", __output_dir, __instance_id, __session_id, __current_index++); int fd = open(path, O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR); if (fd == -1) { AOUT("failed to open new input file for write"); return; } AOUT("generate #%d output (size: %zu -> %zu)\n", __current_index - 1, input_size, new_input.size()); if (write(fd, new_input.data(), new_input.size()) == -1) { AOUT("failed to write new input\n"); } close(fd); } static void __solve_cond(dfsan_label label, uint8_t r, bool add_nested, void *addr) { AOUT("solving label %d = %d, add_nested: %d\n", label, r, add_nested); std::vector tasks; if (__z3_parser->parse_cond(label, r, add_nested, tasks)) { AOUT("WARNING: failed to parse condition %d @%p\n", label, addr); return; } for (auto id : tasks) { // solve symsan::Z3ParserSolver::solution_t solutions; auto status = __z3_parser->solve_task(id, 30000U, solutions); // 30 seconds if (solutions.size() != 0) { AOUT("branch solved\n"); generate_input(solutions); } else { AOUT("branch not solvable @%p\n", addr); } solutions.clear(); } } static void __handle_gep(dfsan_label ptr_label, uptr ptr, dfsan_label index_label, int64_t index, uint64_t num_elems, uint64_t elem_size, int64_t current_offset, void* addr) { AOUT("tainted GEP index: %ld = %d, ne: %ld, es: %ld, offset: %ld\n", index, index_label, num_elems, elem_size, current_offset); std::vector tasks; if (__z3_parser->parse_gep(ptr_label, ptr, index_label, index, num_elems, elem_size, current_offset, __enum_gep, tasks)) { AOUT("WARNING: failed to parse gep %d @%p\n", index_label, addr); return; } for (auto id : tasks) { symsan::Z3ParserSolver::solution_t solutions; auto status = __z3_parser->solve_task(id, 30000U, solutions); // 30 seconds if (solutions.size() != 0) { AOUT("gep solved\n"); generate_input(solutions); } else { AOUT("gep not solvable @%p\n", addr); } solutions.clear(); } } int main(int argc, char* const argv[]) { if (argc != 3) { fprintf(stderr, "Usage: %s target input\n", argv[0]); exit(1); } char *program = argv[1]; char *input = argv[2]; int is_stdin = 0; int solve_ub = 0; int debug = 0; char *options = getenv("TAINT_OPTIONS"); if (options) { // setup output dir char *output = strstr(options, "output_dir="); if (output) { output += 11; // skip "output_dir=" char *end = strchr(output, ':'); // try ':' first, then ' ' if (end == NULL) end = strchr(output, ' '); size_t n = end == NULL? strlen(output) : (size_t)(end - output); __output_dir = strndup(output, n); } // check if input is stdin char *taint_file = strstr(options, "taint_file="); if (taint_file) { taint_file += strlen("taint_file="); // skip "taint_file=" char *end = strchr(taint_file, ':'); if (end == NULL) end = strchr(taint_file, ' '); size_t n = end == NULL? strlen(taint_file) : (size_t)(end - taint_file); if (n == 5 && !strncmp(taint_file, "stdin", 5)) is_stdin = 1; } // check for debug char *debug_opt = strstr(options, "debug="); if (debug_opt) { debug_opt += strlen("debug="); // skip "debug=" if (strcmp(debug_opt, "1") == 0 || strcmp(debug_opt, "true") == 0) debug = 1; } // check for session_id char *session_opt = strstr(options, "session_id="); if (session_opt) { session_opt += strlen("session_id="); __session_id = atoi(session_opt); } // check if solve_ub is enabled char *solve_ub_opt = strstr(options, "solve_ub="); if (solve_ub_opt) { solve_ub_opt += strlen("solve_ub="); // skip "solve_ub=" if (strcmp(solve_ub_opt, "1") == 0 || strcmp(solve_ub_opt, "true") == 0) solve_ub = 1; } // check if GEP enumeration is disabled char *enum_gep_opt = strstr(options, "enum_gep="); if (enum_gep_opt) { enum_gep_opt += strlen("enum_gep="); // skip "enum_gep=" if (strncmp(enum_gep_opt, "0", 1) == 0 || strncmp(enum_gep_opt, "false", 5) == 0) __enum_gep = 0; } } // load input file struct stat st; int input_fd = open(input, O_RDONLY); if (input_fd == -1) { fprintf(stderr, "Failed to open input file: %s\n", strerror(errno)); exit(1); } fstat(input_fd, &st); input_size = st.st_size; input_buf = (char *)mmap(NULL, input_size, PROT_READ, MAP_PRIVATE, input_fd, 0); if (input_buf == (void *)-1) { fprintf(stderr, "Failed to map input file: %s\n", strerror(errno)); exit(1); } // setup launcher void *shm_base = symsan_init(program, uniontable_size); if (shm_base == (void *)-1) { fprintf(stderr, "Failed to map shm: %s\n", strerror(errno)); exit(1); } if (symsan_set_input(is_stdin ? "stdin" : input) != 0) { fprintf(stderr, "Failed to set input\n"); exit(1); } char* args[3]; args[0] = program; args[1] = input; args[2] = NULL; if (symsan_set_args(2, args) != 0) { fprintf(stderr, "Failed to set args\n"); exit(1); } symsan_set_debug(debug); symsan_set_bounds_check(1); symsan_set_solve_ub(solve_ub); // launch the target int ret = symsan_run(input_fd); if (ret < 0) { fprintf(stderr, "Failed to launch target: %s\n", strerror(errno)); exit(1); } else if (ret > 0) { fprintf(stderr, "SymSan launch error %d\n", ret); exit(1); } close(input_fd); // setup z3 parser __z3_parser = new symsan::Z3ParserSolver(shm_base, uniontable_size, __z3_context); std::vector inputs; inputs.push_back({(uint8_t*)input_buf, input_size}); if (__z3_parser->restart(inputs) != 0) { fprintf(stderr, "Failed to restart parser\n"); exit(1); } pipe_msg msg; gep_msg gmsg; size_t msg_size; memcmp_msg *mmsg = nullptr; while (symsan_read_event(&msg, sizeof(msg), 0) > 0) { // solve constraints switch (msg.msg_type) { case cond_type: __solve_cond(msg.label, msg.result, msg.flags & F_ADD_CONS, (void*)msg.addr); break; case gep_type: if (symsan_read_event(&gmsg, sizeof(gmsg), 0) != sizeof(gmsg)) { fprintf(stderr, "Failed to receive gep msg: %s\n", strerror(errno)); break; } // double check if (msg.label != gmsg.index_label) { fprintf(stderr, "Incorrect gep msg: %d vs %d\n", msg.label, gmsg.index_label); break; } __handle_gep(gmsg.ptr_label, gmsg.ptr, gmsg.index_label, gmsg.index, gmsg.num_elems, gmsg.elem_size, gmsg.current_offset, (void*)msg.addr); break; case memcmp_type: // flags = 0 means both operands are symbolic thus no content to read if (!msg.flags) break; msg_size = sizeof(memcmp_msg) + msg.result; mmsg = (memcmp_msg*)malloc(msg_size); // not freed until terminate if (symsan_read_event(mmsg, msg_size, 0) != msg_size) { fprintf(stderr, "Failed to receive memcmp msg: %s\n", strerror(errno)); free(mmsg); break; } // double check if (msg.label != mmsg->label) { fprintf(stderr, "Incorrect memcmp msg: %d vs %d\n", msg.label, mmsg->label); free(mmsg); break; } // save the content __z3_parser->record_memcmp(msg.label, mmsg->content, msg.result); free(mmsg); break; case fsize_type: break; default: break; } } symsan_destroy(); exit(0); } ================================================ FILE: driver/harness-proxy.c ================================================ // Copyright 2021 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include #include #include #include #include #include #include extern int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size); __attribute__((weak)) int LLVMFuzzerInitialize(int *argc, char ***argv); __attribute__((weak)) void LLVMFuzzerCleanup(void); int main(int argc, char* argv[]) { // Initialize the fuzzer if the function is available if (LLVMFuzzerInitialize) { LLVMFuzzerInitialize(&argc, &argv); } // open file int fd = open(argv[1], O_RDONLY); if (fd < 0) { perror("open"); return 1; } // get file size struct stat st; if (fstat(fd, &st) < 0) { perror("fstat"); close(fd); return 1; } size_t fsize = st.st_size; // read file contents char *string = (char*)malloc(fsize); if (read(fd, string, fsize) != fsize) { perror("read"); close(fd); return 1; } close(fd); // Now call into the harness int retval = LLVMFuzzerTestOneInput((const uint8_t *)string, fsize); free(string); // Cleanup if the function is available if (LLVMFuzzerCleanup) { LLVMFuzzerCleanup(); } return retval; } ================================================ FILE: driver/launcher/CMakeLists.txt ================================================ set(CMAKE_POSITION_INDEPENDENT_CODE ON) set(CMAKE_CXX_STANDARD 14) add_library(launcher STATIC launch.c) ================================================ FILE: driver/launcher/launch.c ================================================ #include "defs.h" #include "debug.h" #include "version.h" #include "launch.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #undef alloc_printf #define alloc_printf(_str...) ({ \ char* _tmp; \ s32 _len = snprintf(NULL, 0, _str); \ if (_len < 0) FATAL("Whoa, snprintf() fails?!"); \ _tmp = (char*)malloc(_len + 1); \ snprintf((char*)_tmp, _len + 1, _str); \ _tmp; \ }) struct symsan_config { char *symsan_bin; char *input_file; char **argv; char *shm_name; int shm_fd; void *label_info; int pipefds[2]; char *symsan_env; int symsan_pid; size_t shm_size; int is_input_file; int is_input_sdtin; int is_input_network; int enable_debug; int enable_bounds_check; int enable_solve_ub; int exit_on_memerror; int trace_file_size; int force_stdin; int dev_null_fd; int exit_status; int is_killed; }; static struct symsan_config g_config; __attribute__((visibility("default"))) void* symsan_init(const char *symsan_bin, const size_t uniontable_size) { if (!symsan_bin) { return (void *)-1; } g_config.symsan_bin = strdup(symsan_bin); g_config.input_file = NULL; g_config.argv = NULL; g_config.shm_name = NULL; g_config.shm_fd = -1; g_config.label_info = NULL; g_config.shm_size = uniontable_size; g_config.pipefds[0] = -1; g_config.pipefds[1] = -1; g_config.symsan_env = NULL; g_config.symsan_pid = -1; g_config.is_input_file = 0; g_config.is_input_sdtin = 0; g_config.is_input_network = 0; g_config.enable_debug = 0; g_config.enable_bounds_check = 0; g_config.enable_solve_ub = 0; g_config.exit_on_memerror = 1; g_config.trace_file_size = 0; g_config.force_stdin = 0; g_config.dev_null_fd = -1; g_config.exit_status = 0; g_config.is_killed = 0; // open /dev/null g_config.dev_null_fd = open("/dev/null", O_RDWR); if (g_config.dev_null_fd == -1) { return (void *)-1; } // create a new shm name g_config.shm_name = alloc_printf("/symsan-union-table-%d", getpid()); if (!g_config.shm_name) { return (void *)-1; } // create shm g_config.shm_fd = shm_open(g_config.shm_name, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR); if (g_config.shm_fd == -1) { return (void *)-1; } // set the size of the shm if (ftruncate(g_config.shm_fd, uniontable_size) == -1) { return (void *)-1; } // clear O_CLOEXEC flag fcntl(g_config.shm_fd, F_SETFD, fcntl(g_config.shm_fd, F_GETFD) & ~FD_CLOEXEC); // mmap the shm g_config.label_info = mmap(NULL, uniontable_size, PROT_READ, MAP_SHARED, g_config.shm_fd, 0); return g_config.label_info; } __attribute__((visibility("default"))) int symsan_set_input(const char *input) { if (!input) { return SYMSAN_INVALID_ARGS; } g_config.input_file = strdup(input); if (!g_config.input_file) { return SYMSAN_NO_MEMORY; } if (strcmp(input, "stdin") == 0) { g_config.is_input_sdtin = 1; } else if (strstr(input, "tcp@") == input) { g_config.is_input_network = 1; } else if (strstr(input, "udp@") == input) { g_config.is_input_network = 1; } else if (strstr(input, "unix@") == input) { g_config.is_input_network = 1; } else { g_config.is_input_file = 1; } return 0; } __attribute__((visibility("default"))) int symsan_set_args(const int argc, char* const argv[]) { if (argc < 1 || !argv) { return SYMSAN_INVALID_ARGS; } g_config.argv = (char **)malloc(sizeof(char *) * (argc + 1)); if (!g_config.argv) { return SYMSAN_NO_MEMORY; } int err = 0, i = 0; for (;i < argc; i++) { if (!argv[i]) { err = SYMSAN_INVALID_ARGS; goto error; } g_config.argv[i] = strdup(argv[i]); if (!g_config.argv[i]) { err = SYMSAN_NO_MEMORY; goto error; } } g_config.argv[argc] = NULL; return 0; error: for (int j = 0; j < i; j++) { free(g_config.argv[j]); } free(g_config.argv); g_config.argv = NULL; return err; } __attribute__((visibility("default"))) int symsan_set_debug(int enable) { g_config.enable_debug = !!enable; return 0; } __attribute__((visibility("default"))) int symsan_set_bounds_check(int enable) { g_config.enable_bounds_check = !!enable; return 0; } __attribute__((visibility("default"))) int symsan_set_solve_ub(int enable) { g_config.enable_solve_ub = !!enable; return 0; } __attribute__((visibility("default"))) int symsan_set_exit_on_memerror(int enable) { g_config.exit_on_memerror = !!enable; return 0; } __attribute__((visibility("default"))) int symsan_set_trace_file_size(int enable) { g_config.trace_file_size = !!enable; return 0; } __attribute__((visibility("default"))) int symsan_set_force_stdin(int enable) { g_config.force_stdin = !!enable; return 0; } __attribute__((visibility("default"))) int symsan_run(int fd) { if (fd < 0) { return SYMSAN_INVALID_ARGS; } if (!g_config.symsan_bin) { return SYMSAN_MISSING_BIN; } if (!g_config.label_info) { return SYMSAN_MISSING_SHM; } if (!g_config.input_file) { return SYMSAN_MISSING_INPUT; } if (!g_config.argv) { return SYMSAN_MISSING_ARGS; } if (g_config.is_input_network && !g_config.input_file) { return SYMSAN_MISSING_INPUT; } // unlikely but double check if (g_config.pipefds[0] != -1) { close(g_config.pipefds[0]); } if (g_config.pipefds[1] != -1) { close(g_config.pipefds[1]); } if (g_config.symsan_env == NULL) { free(g_config.symsan_env); } int ret = pipe(g_config.pipefds); if (ret != 0) { return SYMSAN_NO_MEMORY; } // fds and configs could have been changed, so always set up new ones g_config.symsan_env = alloc_printf( "taint_file=\"%s\":shm_fd=%d:pipe_fd=%d:debug=%d:trace_bounds=%d:" "solve_ub=%d:exit_on_memerror=%d:trace_fsize=%d:force_stdin=%d", g_config.input_file, g_config.shm_fd, g_config.pipefds[1], g_config.enable_debug, g_config.enable_bounds_check, g_config.enable_solve_ub, g_config.exit_on_memerror, g_config.trace_file_size, g_config.force_stdin); if (g_config.symsan_env == NULL) { return SYMSAN_NO_MEMORY; } if (g_config.enable_debug) { fprintf(stderr, "SYMSAN_ENV: %s\n", g_config.symsan_env); } g_config.symsan_pid = fork(); if (g_config.symsan_pid == 0) { // clear signal handlers and masks sigset_t set; sigemptyset(&set); sigprocmask(SIG_SETMASK, &set, NULL); // disable core dump as shadow mem is toooooo large struct rlimit limit; limit.rlim_cur = limit.rlim_max = 0; setrlimit(RLIMIT_CORE, &limit); close(g_config.pipefds[0]); // close the read fd setenv("TAINT_OPTIONS", (char*)g_config.symsan_env, 1); unsetenv("LD_PRELOAD"); // don't preload anything if (g_config.is_input_sdtin) { close(0); lseek(fd, 0, SEEK_SET); dup2(fd, 0); } if (!g_config.enable_debug) { close(1); close(2); int dev_null_fd = open("/dev/null", O_RDWR); dup2(g_config.dev_null_fd, 1); dup2(g_config.dev_null_fd, 2); } ret = execv(g_config.symsan_bin, g_config.argv); return ret; } else if (g_config.symsan_pid < 0) { close(g_config.pipefds[0]); close(g_config.pipefds[1]); return g_config.symsan_pid; } free(g_config.symsan_env); g_config.symsan_env = NULL; close(g_config.pipefds[1]); // close the write fd g_config.pipefds[1] = -1; g_config.is_killed = 0; // reset kill flag return 0; } __attribute__((visibility("default"))) ssize_t symsan_read_event(void *buf, size_t size, unsigned int timeout) { if (size == 0) { return 0; } int ret = 1; if (timeout) { fd_set rfds; struct timeval tv; FD_ZERO(&rfds); FD_SET(g_config.pipefds[0], &rfds); tv.tv_sec = (timeout / 1000); tv.tv_usec = (timeout % 1000) * 1000; ret = select(g_config.pipefds[0] + 1, &rfds, NULL, NULL, &tv); } ssize_t n = -1; if (ret > 0) { // no timeout or select okay n = read(g_config.pipefds[0], buf, size); } else { // time out or error on select kill(g_config.symsan_pid, SIGKILL); g_config.is_killed = 1; } if (n != size) { // error or EOF waitpid(g_config.symsan_pid, &g_config.exit_status, 0); g_config.symsan_pid = -1; close(g_config.pipefds[0]); // close the read fd g_config.pipefds[0] = -1; } return n; } __attribute__((visibility("default"))) int symsan_terminate() { if (g_config.symsan_pid == -1) { // already terminated return 0; } else if (g_config.symsan_pid > 0) { kill(g_config.symsan_pid, SIGKILL); g_config.is_killed = 1; waitpid(g_config.symsan_pid, &g_config.exit_status, 0); g_config.symsan_pid = -1; close(g_config.pipefds[0]); return 0; } else { return -1; } } __attribute__((visibility("default"))) int symsan_get_exit_status(int *status) { if (!status) { return -1; } *status = g_config.exit_status; return g_config.is_killed; } __attribute__((visibility("default"))) void symsan_destroy() { symsan_terminate(); if (g_config.label_info != NULL) { munmap(g_config.label_info, g_config.shm_size); g_config.label_info = NULL; } if (g_config.dev_null_fd != -1) { close(g_config.dev_null_fd); g_config.dev_null_fd = -1; } if (g_config.shm_fd != -1) { close(g_config.shm_fd); g_config.shm_fd = -1; } if (g_config.shm_name != NULL) { shm_unlink(g_config.shm_name); free(g_config.shm_name); g_config.shm_name = NULL; } if (g_config.input_file != NULL) { free(g_config.input_file); g_config.input_file = NULL; } if (g_config.argv != NULL) { for (int i = 0; g_config.argv[i]; i++) { free(g_config.argv[i]); } free(g_config.argv); g_config.argv = NULL; } if (g_config.symsan_env != NULL) { free(g_config.symsan_env); g_config.symsan_env = NULL; } if (g_config.symsan_bin != NULL) { free(g_config.symsan_bin); g_config.symsan_bin = NULL; } if (g_config.pipefds[0] != -1) { close(g_config.pipefds[0]); g_config.pipefds[0] = -1; } if (g_config.pipefds[1] != -1) { close(g_config.pipefds[1]); g_config.pipefds[1] = -1; } } ================================================ FILE: include/alloc_inl.h ================================================ /* american fuzzy lop - error-checking, memory-zeroing alloc routines ------------------------------------------------------------------ Written and maintained by Michal Zalewski Copyright 2013, 2014, 2015 Google Inc. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0 This allocator is not designed to resist malicious attackers (the canaries are small and predictable), but provides a robust and portable way to detect use-after-free, off-by-one writes, stale pointers, and so on. */ #ifndef _HAVE_ALLOC_INL_H #define _HAVE_ALLOC_INL_H #include #include #include #include "defs.h" //#include "types.h" #include "debug.h" #define MAX_ALLOC 0x40000000 /* User-facing macro to sprintf() to a dynamically allocated buffer. */ #define alloc_printf(_str...) ({ \ char* _tmp; \ s32 _len = snprintf(NULL, 0, _str); \ if (_len < 0) FATAL("Whoa, snprintf() fails?!"); \ _tmp = ck_alloc(_len + 1); \ snprintf((char*)_tmp, _len + 1, _str); \ _tmp; \ }) /* Macro to enforce allocation limits as a last-resort defense against integer overflows. */ #define ALLOC_CHECK_SIZE(_s) do { \ if ((_s) > MAX_ALLOC) \ ABORT("Bad alloc request: %u bytes", (_s)); \ } while (0) /* Macro to check malloc() failures and the like. */ #define ALLOC_CHECK_RESULT(_r, _s) do { \ if (!(_r)) \ ABORT("Out of memory: can't allocate %u bytes", (_s)); \ } while (0) /* Magic tokens used to mark used / freed chunks. */ #define ALLOC_MAGIC_C1 0xFF00FF00 /* Used head (dword) */ #define ALLOC_MAGIC_F 0xFE00FE00 /* Freed head (dword) */ #define ALLOC_MAGIC_C2 0xF0 /* Used tail (byte) */ /* Positions of guard tokens in relation to the user-visible pointer. */ #define ALLOC_C1(_ptr) (((u32*)(_ptr))[-2]) #define ALLOC_S(_ptr) (((u32*)(_ptr))[-1]) #define ALLOC_C2(_ptr) (((u8*)(_ptr))[ALLOC_S(_ptr)]) #define ALLOC_OFF_HEAD 8 #define ALLOC_OFF_TOTAL (ALLOC_OFF_HEAD + 1) /* Allocator increments for ck_realloc_block(). */ #define ALLOC_BLK_INC 256 /* Sanity-checking macros for pointers. */ #define CHECK_PTR(_p) do { \ if (_p) { \ if (ALLOC_C1(_p) ^ ALLOC_MAGIC_C1) {\ if (ALLOC_C1(_p) == ALLOC_MAGIC_F) \ ABORT("Use after free."); \ else ABORT("Corrupted head alloc canary."); \ } \ if (ALLOC_C2(_p) ^ ALLOC_MAGIC_C2) \ ABORT("Corrupted tail alloc canary."); \ } \ } while (0) #define CHECK_PTR_EXPR(_p) ({ \ typeof (_p) _tmp = (_p); \ CHECK_PTR(_tmp); \ _tmp; \ }) /* Allocate a buffer, explicitly not zeroing it. Returns NULL for zero-sized requests. */ static inline void* DFL_ck_alloc_nozero(u32 size) { void* ret; if (!size) return NULL; ALLOC_CHECK_SIZE(size); ret = malloc(size + ALLOC_OFF_TOTAL); ALLOC_CHECK_RESULT(ret, size); ret += ALLOC_OFF_HEAD; ALLOC_C1(ret) = ALLOC_MAGIC_C1; ALLOC_S(ret) = size; ALLOC_C2(ret) = ALLOC_MAGIC_C2; return ret; } /* Allocate a buffer, returning zeroed memory. */ static inline void* DFL_ck_alloc(u32 size) { void* mem; if (!size) return NULL; mem = DFL_ck_alloc_nozero(size); return memset(mem, 0, size); } /* Free memory, checking for double free and corrupted heap. When DEBUG_BUILD is set, the old memory will be also clobbered with 0xFF. */ static inline void DFL_ck_free(void* mem) { if (!mem) return; CHECK_PTR(mem); #ifdef DEBUG_BUILD /* Catch pointer issues sooner. */ memset(mem, 0xFF, ALLOC_S(mem)); #endif /* DEBUG_BUILD */ ALLOC_C1(mem) = ALLOC_MAGIC_F; free(mem - ALLOC_OFF_HEAD); } /* Re-allocate a buffer, checking for issues and zeroing any newly-added tail. With DEBUG_BUILD, the buffer is always reallocated to a new addresses and the old memory is clobbered with 0xFF. */ static inline void* DFL_ck_realloc(void* orig, u32 size) { void* ret; u32 old_size = 0; if (!size) { DFL_ck_free(orig); return NULL; } if (orig) { CHECK_PTR(orig); #ifndef DEBUG_BUILD ALLOC_C1(orig) = ALLOC_MAGIC_F; #endif /* !DEBUG_BUILD */ old_size = ALLOC_S(orig); orig -= ALLOC_OFF_HEAD; ALLOC_CHECK_SIZE(old_size); } ALLOC_CHECK_SIZE(size); #ifndef DEBUG_BUILD ret = realloc(orig, size + ALLOC_OFF_TOTAL); ALLOC_CHECK_RESULT(ret, size); #else /* Catch pointer issues sooner: force relocation and make sure that the original buffer is wiped. */ ret = malloc(size + ALLOC_OFF_TOTAL); ALLOC_CHECK_RESULT(ret, size); if (orig) { memcpy(ret + ALLOC_OFF_HEAD, orig + ALLOC_OFF_HEAD, MIN(size, old_size)); memset(orig + ALLOC_OFF_HEAD, 0xFF, old_size); ALLOC_C1(orig + ALLOC_OFF_HEAD) = ALLOC_MAGIC_F; free(orig); } #endif /* ^!DEBUG_BUILD */ ret += ALLOC_OFF_HEAD; ALLOC_C1(ret) = ALLOC_MAGIC_C1; ALLOC_S(ret) = size; ALLOC_C2(ret) = ALLOC_MAGIC_C2; if (size > old_size) memset(ret + old_size, 0, size - old_size); return ret; } /* Re-allocate a buffer with ALLOC_BLK_INC increments (used to speed up repeated small reallocs without complicating the user code). */ static inline void* DFL_ck_realloc_block(void* orig, u32 size) { #ifndef DEBUG_BUILD if (orig) { CHECK_PTR(orig); if (ALLOC_S(orig) >= size) return orig; size += ALLOC_BLK_INC; } #endif /* !DEBUG_BUILD */ return DFL_ck_realloc(orig, size); } /* Create a buffer with a copy of a string. Returns NULL for NULL inputs. */ static inline char* DFL_ck_strdup(char* str) { void* ret; u32 size; if (!str) return NULL; size = strlen((char*)str) + 1; ALLOC_CHECK_SIZE(size); ret = malloc(size + ALLOC_OFF_TOTAL); ALLOC_CHECK_RESULT(ret, size); ret += ALLOC_OFF_HEAD; ALLOC_C1(ret) = ALLOC_MAGIC_C1; ALLOC_S(ret) = size; ALLOC_C2(ret) = ALLOC_MAGIC_C2; return memcpy(ret, str, size); } /* Create a buffer with a copy of a memory block. Returns NULL for zero-sized or NULL inputs. */ static inline void* DFL_ck_memdup(void* mem, u32 size) { void* ret; if (!mem || !size) return NULL; ALLOC_CHECK_SIZE(size); ret = malloc(size + ALLOC_OFF_TOTAL); ALLOC_CHECK_RESULT(ret, size); ret += ALLOC_OFF_HEAD; ALLOC_C1(ret) = ALLOC_MAGIC_C1; ALLOC_S(ret) = size; ALLOC_C2(ret) = ALLOC_MAGIC_C2; return memcpy(ret, mem, size); } /* Create a buffer with a block of text, appending a NUL terminator at the end. Returns NULL for zero-sized or NULL inputs. */ static inline u8* DFL_ck_memdup_str(u8* mem, u32 size) { u8* ret; if (!mem || !size) return NULL; ALLOC_CHECK_SIZE(size); ret = malloc(size + ALLOC_OFF_TOTAL + 1); ALLOC_CHECK_RESULT(ret, size); ret += ALLOC_OFF_HEAD; ALLOC_C1(ret) = ALLOC_MAGIC_C1; ALLOC_S(ret) = size; ALLOC_C2(ret) = ALLOC_MAGIC_C2; memcpy(ret, mem, size); ret[size] = 0; return ret; } #ifndef DEBUG_BUILD /* In non-debug mode, we just do straightforward aliasing of the above functions to user-visible names such as ck_alloc(). */ #define ck_alloc DFL_ck_alloc #define ck_alloc_nozero DFL_ck_alloc_nozero #define ck_realloc DFL_ck_realloc #define ck_realloc_block DFL_ck_realloc_block #define ck_strdup DFL_ck_strdup #define ck_memdup DFL_ck_memdup #define ck_memdup_str DFL_ck_memdup_str #define ck_free DFL_ck_free #define alloc_report() #else /* In debugging mode, we also track allocations to detect memory leaks, and the flow goes through one more layer of indirection. */ /* Alloc tracking data structures: */ #define ALLOC_BUCKETS 4096 struct TRK_obj { void *ptr; char *file, *func; u32 line; }; #ifdef AFL_MAIN struct TRK_obj* TRK[ALLOC_BUCKETS]; u32 TRK_cnt[ALLOC_BUCKETS]; # define alloc_report() TRK_report() #else extern struct TRK_obj* TRK[ALLOC_BUCKETS]; extern u32 TRK_cnt[ALLOC_BUCKETS]; # define alloc_report() #endif /* ^AFL_MAIN */ /* Bucket-assigning function for a given pointer: */ #define TRKH(_ptr) (((((u32)(_ptr)) >> 16) ^ ((u32)(_ptr))) % ALLOC_BUCKETS) /* Add a new entry to the list of allocated objects. */ static inline void TRK_alloc_buf(void* ptr, const char* file, const char* func, u32 line) { u32 i, bucket; if (!ptr) return; bucket = TRKH(ptr); /* Find a free slot in the list of entries for that bucket. */ for (i = 0; i < TRK_cnt[bucket]; i++) if (!TRK[bucket][i].ptr) { TRK[bucket][i].ptr = ptr; TRK[bucket][i].file = (char*)file; TRK[bucket][i].func = (char*)func; TRK[bucket][i].line = line; return; } /* No space available - allocate more. */ TRK[bucket] = DFL_ck_realloc_block(TRK[bucket], (TRK_cnt[bucket] + 1) * sizeof(struct TRK_obj)); TRK[bucket][i].ptr = ptr; TRK[bucket][i].file = (char*)file; TRK[bucket][i].func = (char*)func; TRK[bucket][i].line = line; TRK_cnt[bucket]++; } /* Remove entry from the list of allocated objects. */ static inline void TRK_free_buf(void* ptr, const char* file, const char* func, u32 line) { u32 i, bucket; if (!ptr) return; bucket = TRKH(ptr); /* Find the element on the list... */ for (i = 0; i < TRK_cnt[bucket]; i++) if (TRK[bucket][i].ptr == ptr) { TRK[bucket][i].ptr = 0; return; } WARNF("ALLOC: Attempt to free non-allocated memory in %s (%s:%u)", func, file, line); } /* Do a final report on all non-deallocated objects. */ static inline void TRK_report(void) { u32 i, bucket; fflush(0); for (bucket = 0; bucket < ALLOC_BUCKETS; bucket++) for (i = 0; i < TRK_cnt[bucket]; i++) if (TRK[bucket][i].ptr) WARNF("ALLOC: Memory never freed, created in %s (%s:%u)", TRK[bucket][i].func, TRK[bucket][i].file, TRK[bucket][i].line); } /* Simple wrappers for non-debugging functions: */ static inline void* TRK_ck_alloc(u32 size, const char* file, const char* func, u32 line) { void* ret = DFL_ck_alloc(size); TRK_alloc_buf(ret, file, func, line); return ret; } static inline void* TRK_ck_realloc(void* orig, u32 size, const char* file, const char* func, u32 line) { void* ret = DFL_ck_realloc(orig, size); TRK_free_buf(orig, file, func, line); TRK_alloc_buf(ret, file, func, line); return ret; } static inline void* TRK_ck_realloc_block(void* orig, u32 size, const char* file, const char* func, u32 line) { void* ret = DFL_ck_realloc_block(orig, size); TRK_free_buf(orig, file, func, line); TRK_alloc_buf(ret, file, func, line); return ret; } static inline void* TRK_ck_strdup(u8* str, const char* file, const char* func, u32 line) { void* ret = DFL_ck_strdup(str); TRK_alloc_buf(ret, file, func, line); return ret; } static inline void* TRK_ck_memdup(void* mem, u32 size, const char* file, const char* func, u32 line) { void* ret = DFL_ck_memdup(mem, size); TRK_alloc_buf(ret, file, func, line); return ret; } static inline void* TRK_ck_memdup_str(void* mem, u32 size, const char* file, const char* func, u32 line) { void* ret = DFL_ck_memdup_str(mem, size); TRK_alloc_buf(ret, file, func, line); return ret; } static inline void TRK_ck_free(void* ptr, const char* file, const char* func, u32 line) { TRK_free_buf(ptr, file, func, line); DFL_ck_free(ptr); } /* Aliasing user-facing names to tracking functions: */ #define ck_alloc(_p1) \ TRK_ck_alloc(_p1, __FILE__, __FUNCTION__, __LINE__) #define ck_alloc_nozero(_p1) \ TRK_ck_alloc(_p1, __FILE__, __FUNCTION__, __LINE__) #define ck_realloc(_p1, _p2) \ TRK_ck_realloc(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) #define ck_realloc_block(_p1, _p2) \ TRK_ck_realloc_block(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) #define ck_strdup(_p1) \ TRK_ck_strdup(_p1, __FILE__, __FUNCTION__, __LINE__) #define ck_memdup(_p1, _p2) \ TRK_ck_memdup(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) #define ck_memdup_str(_p1, _p2) \ TRK_ck_memdup_str(_p1, _p2, __FILE__, __FUNCTION__, __LINE__) #define ck_free(_p1) \ TRK_ck_free(_p1, __FILE__, __FUNCTION__, __LINE__) #endif /* ^!DEBUG_BUILD */ #endif /* ! _HAVE_ALLOC_INL_H */ ================================================ FILE: include/ast.h ================================================ #pragma once #include #include #include #include namespace rgd { enum AstKind { Bool, // 0 Constant, // 1 Read, // 2 Concat, // 3 Extract, // 4 ZExt, // 5 SExt, // 6 // Arithmetic Add, // 7 Sub, // 8 Mul, // 9 UDiv, // 10 SDiv, // 11 URem, // 12 SRem, // 13 Neg, // 14 // Bit Not, // 15 And, // 16 Or, // 17 Xor, // 18 Shl, // 19 LShr, // 20 AShr, // 21 // Compare Equal, // 22 Distinct, // 23 Ult, // 24 Ule, // 25 Ugt, // 26 Uge, // 27 Slt, // 28 Sle, // 29 Sgt, // 30 Sge, // 31 // Logical LOr, // 32 LAnd, // 33 LNot, // 34 // Special Ite, // 35 Load, // 36 to be worked with TT-Fuzzer Memcmp, //37 MemcmpN, // 38 // Last LastOp }; static const char* AstKindName[] = { "Bool", "Constant", "Read", "Concat", "Extract", "ZExt", "SExt", "Add", "Sub", "Mul", "UDiv", "SDiv", "URem", "SRem", "Neg", "Not", "And", "Or", "Xor", "Shl", "LShr", "AShr", "Equal", "Distinct", "Ult", "Ule", "Ugt", "Uge", "Slt", "Sle", "Sgt", "Sge", "LOr", "LAnd", "LNot", "Ite", "Load", "Memcmp", "MemcmpN", }; static inline bool isRelationalKind(uint16_t kind) { if (kind >= Equal && kind <= Sge) return true; else return false; } static inline bool isBinaryOperation(uint16_t kind) { if (kind >= Add && kind <= AShr && kind != Neg && kind != Not) return true; else return false; } static inline uint16_t negate_cmp(uint16_t kind) { switch (kind) { case Equal: return Distinct; case Distinct: return Equal; case Ult: return Uge; case Ule: return Ugt; case Ugt: return Ule; case Uge: return Ult; case Slt: return Sge; case Sle: return Sgt; case Sgt: return Sle; case Sge: return Slt; default: return Bool; } } static inline bool isSignedCmp(uint16_t kind) { if (kind >= Slt && kind <= Sge) return true; else return false; } class AstNode { public: AstNode(size_t size=32) : child0_(0), child1_(0), kind_(0), bits_(0), index_(0), boolvalue_(0), is_root_(1), label_(0), hash_(0) { root_ = new std::vector(); // only allocate if is root root_->reserve(size + 1); // default capacity, +1 for dummy root root_->emplace_back(AstNode(root_)); // add a dummy root } AstNode(std::vector *r) : root_(r), child0_(0), child1_(0), kind_(0), bits_(0), index_(0), boolvalue_(0), is_root_(0), label_(0), hash_(0) {} // don't allocate if not root ~AstNode() { if (is_root_) delete root_; } inline void CopyFrom(const AstNode& other) { if (this->root_ == other.root_) { // don't change is_root_ flag child0_ = other.child0_; child1_ = other.child1_; kind_ = other.kind_; bits_ = other.bits_; index_ = other.index_; boolvalue_ = other.boolvalue_; label_ = other.label_; hash_ = other.hash_; } else { RecursiveCopyFrom(other); } } inline uint32_t children_size() const { return (!!child0_) + (!!child1_); } inline const AstNode& children(uint32_t i) const { if (i >= 2) throw std::out_of_range("children index out of range"); return i == 0 ? root_->at(child0_) : root_->at(child1_); } inline AstNode* mutable_children(uint32_t i) { if (i >= 2) throw std::out_of_range("children index out of range"); return i == 0 ? &root_->at(child0_) : &root_->at(child1_); } AstNode* add_children() { size_t size = root_->size(); // assert(size < root_->capacity() && "cannot resize"); if (size >= root_->capacity()) return nullptr; if (child0_ == 0) child0_ = size; else if (child1_ == 0) child1_ = size; else return nullptr; //assert(false && "too many children"); root_->emplace_back(AstNode(root_)); return &root_->back(); } inline void clear_children() { child0_ = child1_ = 0; } inline void clear_children(uint32_t i) { if (i >= 2) throw std::out_of_range("children index out of range"); if (i == 1) child1_ = 0; else child0_ = child1_; // pop child1 to child0 } inline uint16_t kind() const { return kind_; } inline void set_kind(uint16_t kind) { kind_ = kind; } inline uint16_t bits() const { return bits_; } inline void set_bits(uint16_t bits) { bits_ = bits; } inline uint32_t index() const { return index_; } inline void set_index(uint32_t index) { index_ = index; } inline uint8_t boolvalue() const { return boolvalue_; } inline void set_boolvalue(uint8_t value) { boolvalue_ = value ? 0 : 1; } inline uint32_t label() const { return label_; } inline void set_label(uint32_t label) { label_ = label; } inline uint32_t hash() const { return hash_; } inline void set_hash(uint32_t hash) { hash_ = hash; } private: std::vector *root_; // root of the AST uint32_t child0_; uint32_t child1_; uint16_t kind_; uint16_t bits_; uint32_t index_ : 30; //used by read expr for index and extract expr uint8_t boolvalue_ : 1; //used by bool expr uint8_t is_root_ : 1; // true if this is the root of the AST uint32_t label_; //for expression dedup uint32_t hash_; //for node dedup void RecursiveCopyFrom(const AstNode &other) { // copy children if (other.child0_) { if (this->child0_ == 0) { child0_ = root_->size(); root_->emplace_back(AstNode(root_)); } root_->at(child0_).RecursiveCopyFrom(other.children(0)); } else { child0_ = 0; } if (other.child1_) { if (this->child1_ == 0) { child1_ = root_->size(); root_->emplace_back(AstNode(root_)); } root_->at(child1_).RecursiveCopyFrom(other.children(1)); } else { child1_ = 0; } // copy other fields kind_ = other.kind_; bits_ = other.bits_; index_ = other.index_; boolvalue_ = other.boolvalue_; label_ = other.label_; hash_ = other.hash_; } }; static bool isEqualAstRecursive(const AstNode& lhs, const AstNode& rhs) { // number of operands and size of the operands must match const int children_size = lhs.children_size(); if (children_size != rhs.children_size()) return false; if (lhs.bits() != rhs.bits()) return false; if (lhs.kind() != rhs.kind()) { // to maximize the reuse of JIT'ed functions, jigsaw does not // care about which relational operator is used, as long as // they are both relational operators if (isRelationalKind(lhs.kind()) && isRelationalKind(rhs.kind())) { // do nothing, fall through to compare operands } else { return false; } } else if (lhs.hash() != rhs.hash()) { // if the kind is the same, then hash has to match return false; } // compare each operand for (int i = 0; i < children_size; i++) { if (!isEqualAstRecursive(lhs.children(i), rhs.children(i))) return false; } return true; } static inline bool isEqualAst(const AstNode& lhs, const AstNode& rhs) { return isEqualAstRecursive(lhs, rhs); } static inline uint32_t xxhash(uint32_t h1, uint32_t h2, uint32_t h3) { const uint32_t PRIME32_1 = 2654435761U; const uint32_t PRIME32_2 = 2246822519U; const uint32_t PRIME32_3 = 3266489917U; const uint32_t PRIME32_4 = 668265263U; const uint32_t PRIME32_5 = 374761393U; #define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r))) uint32_t h32 = PRIME32_5; h32 += h1 * PRIME32_3; h32 = XXH_rotl32(h32, 17) * PRIME32_4; h32 += h2 * PRIME32_3; h32 = XXH_rotl32(h32, 17) * PRIME32_4; h32 += h3 * PRIME32_3; h32 = XXH_rotl32(h32, 17) * PRIME32_4; #undef XXH_rotl32 h32 ^= h32 >> 15; h32 *= PRIME32_2; h32 ^= h32 >> 13; h32 *= PRIME32_3; h32 ^= h32 >> 16; return h32; } static inline void buf_to_hex_string(const uint8_t *buf, unsigned length, std::string &str) { const char hex_table[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; str.clear(); for (unsigned i = 0; i < length; ++i) { uint8_t val = buf[i]; str.push_back(hex_table[val >> 4]); str.push_back(hex_table[val & 0xf]); } } }; // namespace rgd ================================================ FILE: include/cov.h ================================================ #pragma once #include #include #include #include #include namespace rgd { struct BranchContext { void *addr; bool direction; }; struct HybridBranchContext : public BranchContext { uint32_t id; }; struct ContextAwareBranchContext : public BranchContext { uint32_t context; }; struct LoopAwareBranchContext : public BranchContext { uint32_t loop_counter; }; struct HistoryAwareBranchContext : public BranchContext { uint32_t history; }; struct FullBranchContext : public HybridBranchContext, public ContextAwareBranchContext, public LoopAwareBranchContext, public HistoryAwareBranchContext { }; class CovManager { public: virtual ~CovManager() {} virtual const std::shared_ptr // don't want the saved context to be modified add_branch(void *addr, uint32_t id, bool direction, uint32_t context, bool is_loop_header, bool is_loop_exit) = 0; virtual bool is_branch_interesting(const std::shared_ptr context) = 0; }; class EdgeCovManager : public CovManager { private: using BranchTargets = std::pair; std::unordered_map branches; std::shared_ptr _ctx; public: EdgeCovManager() { _ctx = std::make_shared(); } const std::shared_ptr add_branch(void *addr, uint32_t id, bool direction, uint32_t context, bool is_loop_header, bool is_loop_exit) override { auto &itr = branches[addr]; itr.first |= direction? true : false; itr.second |= direction? false : true; _ctx->addr = addr; _ctx->direction = direction; return _ctx; } bool is_branch_interesting(const std::shared_ptr context) override { auto itr = branches.find(context->addr); // assert(itr != branches.end()); if (context->direction) { return itr->second.first == false; } else { return itr->second.second == false; } } }; }; // namespace rgd ================================================ FILE: include/debug.h ================================================ /* american fuzzy lop - debug / error handling macros -------------------------------------------------- Written and maintained by Michal Zalewski Copyright 2013, 2014, 2015, 2016 Google Inc. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0 */ #ifndef _HAVE_DEBUG_H #define _HAVE_DEBUG_H #include #include "defs.h" /******************* * Terminal colors * *******************/ #ifdef USE_COLOR # define cBLK "\x1b[0;30m" # define cRED "\x1b[0;31m" # define cGRN "\x1b[0;32m" # define cBRN "\x1b[0;33m" # define cBLU "\x1b[0;34m" # define cMGN "\x1b[0;35m" # define cCYA "\x1b[0;36m" # define cLGR "\x1b[0;37m" # define cGRA "\x1b[1;90m" # define cLRD "\x1b[1;91m" # define cLGN "\x1b[1;92m" # define cYEL "\x1b[1;93m" # define cLBL "\x1b[1;94m" # define cPIN "\x1b[1;95m" # define cLCY "\x1b[1;96m" # define cBRI "\x1b[1;97m" # define cRST "\x1b[0m" # define bgBLK "\x1b[40m" # define bgRED "\x1b[41m" # define bgGRN "\x1b[42m" # define bgBRN "\x1b[43m" # define bgBLU "\x1b[44m" # define bgMGN "\x1b[45m" # define bgCYA "\x1b[46m" # define bgLGR "\x1b[47m" # define bgGRA "\x1b[100m" # define bgLRD "\x1b[101m" # define bgLGN "\x1b[102m" # define bgYEL "\x1b[103m" # define bgLBL "\x1b[104m" # define bgPIN "\x1b[105m" # define bgLCY "\x1b[106m" # define bgBRI "\x1b[107m" #else # define cBLK "" # define cRED "" # define cGRN "" # define cBRN "" # define cBLU "" # define cMGN "" # define cCYA "" # define cLGR "" # define cGRA "" # define cLRD "" # define cLGN "" # define cYEL "" # define cLBL "" # define cPIN "" # define cLCY "" # define cBRI "" # define cRST "" # define bgBLK "" # define bgRED "" # define bgGRN "" # define bgBRN "" # define bgBLU "" # define bgMGN "" # define bgCYA "" # define bgLGR "" # define bgGRA "" # define bgLRD "" # define bgLGN "" # define bgYEL "" # define bgLBL "" # define bgPIN "" # define bgLCY "" # define bgBRI "" #endif /* ^USE_COLOR */ /************************* * Box drawing sequences * *************************/ #ifdef FANCY_BOXES # define SET_G1 "\x1b)0" /* Set G1 for box drawing */ # define RESET_G1 "\x1b)B" /* Reset G1 to ASCII */ # define bSTART "\x0e" /* Enter G1 drawing mode */ # define bSTOP "\x0f" /* Leave G1 drawing mode */ # define bH "q" /* Horizontal line */ # define bV "x" /* Vertical line */ # define bLT "l" /* Left top corner */ # define bRT "k" /* Right top corner */ # define bLB "m" /* Left bottom corner */ # define bRB "j" /* Right bottom corner */ # define bX "n" /* Cross */ # define bVR "t" /* Vertical, branch right */ # define bVL "u" /* Vertical, branch left */ # define bHT "v" /* Horizontal, branch top */ # define bHB "w" /* Horizontal, branch bottom */ #else # define SET_G1 "" # define RESET_G1 "" # define bSTART "" # define bSTOP "" # define bH "-" # define bV "|" # define bLT "+" # define bRT "+" # define bLB "+" # define bRB "+" # define bX "+" # define bVR "+" # define bVL "+" # define bHT "+" # define bHB "+" #endif /* ^FANCY_BOXES */ /*********************** * Misc terminal codes * ***********************/ #define TERM_HOME "\x1b[H" #define TERM_CLEAR TERM_HOME "\x1b[2J" #define cEOL "\x1b[0K" #define CURSOR_HIDE "\x1b[?25l" #define CURSOR_SHOW "\x1b[?25h" /************************ * Debug & error macros * ************************/ /* Just print stuff to the appropriate stream. */ #ifdef MESSAGES_TO_STDOUT # define SAYF(x...) printf(x) #else # define SAYF(x...) fprintf(stderr, x) #endif /* ^MESSAGES_TO_STDOUT */ /* Show a prefixed warning. */ #define WARNF(x...) do { \ SAYF(cYEL "[!] " cBRI "WARNING: " cRST x); \ SAYF(cRST "\n"); \ } while (0) /* Show a prefixed "doing something" message. */ #define ACTF(x...) do { \ SAYF(cLBL "[*] " cRST x); \ SAYF(cRST "\n"); \ } while (0) /* Show a prefixed "success" message. */ #define OKF(x...) do { \ SAYF(cLGN "[+] " cRST x); \ SAYF(cRST "\n"); \ } while (0) /* Show a prefixed fatal error message (not used in afl). */ #define BADF(x...) do { \ SAYF(cLRD "\n[-] " cRST x); \ SAYF(cRST "\n"); \ } while (0) /* Die with a verbose non-OS fatal error message. */ #define FATAL(x...) do { \ SAYF(bSTOP RESET_G1 CURSOR_SHOW cRST cLRD "\n[-] PROGRAM ABORT : " \ cBRI x); \ SAYF(cLRD "\n Location : " cRST "%s(), %s:%u\n\n", \ __FUNCTION__, __FILE__, __LINE__); \ exit(1); \ } while (0) /* Die by calling abort() to provide a core dump. */ #define ABORT(x...) do { \ SAYF(bSTOP RESET_G1 CURSOR_SHOW cRST cLRD "\n[-] PROGRAM ABORT : " \ cBRI x); \ SAYF(cLRD "\n Stop location : " cRST "%s(), %s:%u\n\n", \ __FUNCTION__, __FILE__, __LINE__); \ abort(); \ } while (0) /* Die while also including the output of perror(). */ #define PFATAL(x...) do { \ fflush(stdout); \ SAYF(bSTOP RESET_G1 CURSOR_SHOW cRST cLRD "\n[-] SYSTEM ERROR : " \ cBRI x); \ SAYF(cLRD "\n Stop location : " cRST "%s(), %s:%u\n", \ __FUNCTION__, __FILE__, __LINE__); \ SAYF(cLRD " OS message : " cRST "%s\n", strerror(errno)); \ exit(1); \ } while (0) /* Die with FAULT() or PFAULT() depending on the value of res (used to interpret different failure modes for read(), write(), etc). */ #define RPFATAL(res, x...) do { \ if (res < 0) PFATAL(x); else FATAL(x); \ } while (0) /* Error-checking versions of read() and write() that call RPFATAL() as appropriate. */ #define ck_write(fd, buf, len, fn) do { \ u32 _len = (len); \ s32 _res = write(fd, buf, _len); \ if (_res != _len) RPFATAL(_res, "Short write to %s", fn); \ } while (0) #define ck_read(fd, buf, len, fn) do { \ u32 _len = (len); \ s32 _res = read(fd, buf, _len); \ if (_res != _len) RPFATAL(_res, "Short read from %s", fn); \ } while (0) #endif /* ! _HAVE_DEBUG_H */ ================================================ FILE: include/defs.h ================================================ #ifndef _HAVE_DEFS_H #define _HAVE_DEFS_H #ifdef DEBUG_INFO // #define DEBUG_PRINTF printf #define DEBUG_PRINTF(...) \ do { \ printf(__VA_ARGS__); \ } while (0) #else #define DEBUG_PRINTF(...) \ do { \ } while (0) #endif #ifndef MIN #define MIN(_a, _b) ((_a) > (_b) ? (_b) : (_a)) #define MAX(_a, _b) ((_a) > (_b) ? (_a) : (_b)) #endif /* !MIN */ #ifndef RRR #define RRR(x) (random() % (x)) #endif #include #include typedef uint32_t dfsan_label; typedef uint8_t u8; typedef uint16_t u16; typedef uint32_t u32; #ifdef __x86_64__ typedef unsigned long long u64; typedef long long s64; #else typedef uint64_t u64; typedef int64_t s64; #endif typedef int8_t s8; typedef int16_t s16; typedef int32_t s32; #endif /* ! _HAVE_DEFS_H */ ================================================ FILE: include/launch.h ================================================ #ifndef SYMSAN_LAUNCH_H #define SYMSAN_LAUNCH_H #include #define SYMSAN_INVALID_ARGS 1; #define SYMSAN_NO_MEMORY 2; #define SYMSAN_MISSING_BIN 3; #define SYMSAN_MISSING_SHM 4; #define SYMSAN_MISSING_INPUT 5; #define SYMSAN_MISSING_ARGS 6; /// @brief initialize symsan launcher /// @param symsan_bin: path to symsan binary /// @param uniontable_size: size of union table /// @return pointer to the mapped union table void* symsan_init(const char *symsan_bin, size_t uniontable_size); /// @brief set the input file for the target binary /// @param input: "stdin" or "file_path" or "protocol@host:port" /// @return success or error code int symsan_set_input(const char *input); /// @brief set the arguments for the target binary /// @param argc: number of arguments /// @param argv: array of arguments /// @return success or error code int symsan_set_args(const int argc, char* const argv[]); /// @brief set the debug mode for the target binary int symsan_set_debug(int enable); /// @brief set the bounds check mode for the target binary int symsan_set_bounds_check(int enable); /// @brief set the solve UB mode for the target binary int symsan_set_solve_ub(int enable); /// @brief set the exit on memory error mode for the target binary int symsan_set_exit_on_memerror(int enable); /// @brief set the trace file size mode for the target binary int symsan_set_trace_file_size(int enable); /// @brief set the force stdin mode for the target binary int symsan_set_force_stdin(int enable); /// @brief run the target binary with the input file descriptor /// @param fd: input file descriptor, only used if input is "stdin" /// @return < 0 on syscall error, > 0 on setup error, 0 on success int symsan_run(int fd); /// @brief read event from target binary, will perform cleanup on timeout and EOF /// @param buf: buffer to read into /// @param size: size of buffer /// @param timeout: timeout in milliseconds, 0 for no timeout /// @return -1 on error, otherwise number of bytes read ssize_t symsan_read_event(void *buf, size_t size, unsigned int timeout); /// @brief terminate target binary int symsan_terminate(); /// @brief retrieve exit status int symsan_get_exit_status(int *status); /// @brief teardown shared men void symsan_destroy(); #endif /* !SYMSAN_LAUNCH_H */ ================================================ FILE: include/parse-rgd.h ================================================ #pragma once #include "parse.h" #include "task.h" #include "union_find.h" #include "boost/dynamic_bitset.hpp" namespace rgd { class RGDAstParser : public symsan::ASTParser { public: RGDAstParser() = delete; RGDAstParser(void *base, size_t size, bool solve_nested = false, size_t max_ast_size = 200) : symsan::ASTParser(base, size), solve_nested_(solve_nested), max_ast_size_(max_ast_size) {} ~RGDAstParser() {} int restart(std::vector &inputs) override; int parse_cond(dfsan_label label, bool result, bool add_nested, std::vector &tasks) override; int parse_gep(dfsan_label ptr_label, uptr ptr, dfsan_label index_label, int64_t index, uint64_t num_elems, uint64_t elem_size, int64_t current_offset, bool enum_index, std::vector &tasks) override; int add_constraints(dfsan_label label, uint64_t result) override; protected: const bool solve_nested_; const size_t max_ast_size_; private: enum ast_node_t { NONE_CMP_NODE = 0, CMP_NODE = 1, INVALID_NODE = 2, CONCRETIZE_NODE = 4, }; using expr_t = std::shared_ptr; using constraint_t = std::shared_ptr; using clause_t = std::vector; using formula_t = std::vector; // caches std::vector inputs_cache; // input cache std::unordered_map root_expr_cache; // label -> root expr std::unordered_map constraint_cache; // label -> constraint std::vector ast_size_cache; // label -> size of the AST std::vector nested_cmp_cache; // label -> nested comparison std::unordered_map concretize_node; // label -> concretize node // dependencies tracking size_t input_size_; // record the whole input size using input_dep_t = boost::dynamic_bitset<>; std::vector branch_to_inputs; // label -> flattened input dependencies // will be flattened to bit \sigma_{i=0}^{input_id}{size_of(input_i)} + offset inline size_t input_to_dep_idx(uint32_t input_id, uint32_t offset) { size_t idx = 0; for (uint32_t i = 0; i < input_id; ++i) { idx += inputs_cache[i].second; } return idx + offset; } UnionFind data_flow_deps; std::vector > input_to_branches; [[nodiscard]] expr_t get_root_expr(dfsan_label label); [[nodiscard]] bool scan_labels(dfsan_label label); [[nodiscard]] int find_roots(dfsan_label label, AstNode *ret, std::unordered_set &subroots); inline dfsan_label strip_zext(dfsan_label label); [[nodiscard]] int to_nnf(bool expected_r, rgd::AstNode *node); void to_dnf(const rgd::AstNode *node, formula_t &formula); [[nodiscard]] task_t construct_task(const clause_t &clause); [[nodiscard]] constraint_t parse_constraint(dfsan_label label); [[nodiscard]] bool do_uta_rel(dfsan_label label, rgd::AstNode *ret, constraint_t constraint, std::unordered_set &visited); uint32_t map_arg(uint32_t input_id, uint32_t offset, uint32_t length, constraint_t constraint); bool save_constraint(expr_t expr, bool result); inline void add_nested_constraint(task_t task, const clause_t &nested_caluse); }; }; // namespace rgd ================================================ FILE: include/parse-z3.h ================================================ #pragma once #include "parse.h" #include namespace symsan { using z3_task_t = std::vector; class Z3AstParser : public ASTParser { public: Z3AstParser() = delete; Z3AstParser(void *base, size_t size, z3::context &context); ~Z3AstParser() { for (Z3_ast ast : expr_cache_) { if (ast != nullptr) { Z3_dec_ref(context_, ast); // decrement reference count } } } int restart(std::vector &inputs) override; int parse_cond(dfsan_label label, bool result, bool add_nested, std::vector &tasks) override; int parse_gep(dfsan_label ptr_label, uptr ptr, dfsan_label index_label, int64_t index, uint64_t num_elems, uint64_t elem_size, int64_t current_offset, bool enum_index, std::vector &tasks) override; int add_constraints(dfsan_label label, uint64_t result) override; protected: z3::context &context_; const char* input_name_format; const char* atoi_name_format; const char* strlen_name_format; // String ranges for null-byte post-processing (input_id -> list of (start, end)) std::unordered_map>> string_ranges_; // String info cache: label -> (input_id, offset, length) struct string_info_t { uint32_t input_id; uint32_t offset; uint32_t length; }; std::unordered_map string_info_cache_; private: // Original input cache std::vector inputs_cache_; // fsize flag bool has_fsize; // input deps using input_dep_set_t = std::unordered_set; // caches std::vector tsize_cache_; std::vector deps_cache_; std::vector expr_cache_; std::vector value_cache_; static const size_t SIZE_INCREMENT = 2048; // dependencies struct expr_hash { std::size_t operator()(const z3::expr &expr) const { return expr.hash(); } }; struct expr_equal { bool operator()(const z3::expr &lhs, const z3::expr &rhs) const { return lhs.id() == rhs.id(); } }; using expr_set_t = std::unordered_set; struct branch_dependency { expr_set_t expr_deps; input_dep_set_t input_deps; }; using branch_dep_t = std::unique_ptr; using offset_dep_t = std::vector; std::vector branch_deps_; inline struct branch_dependency* get_branch_dep(offset_t off) { auto &offset_deps = branch_deps_.at(off.first); return offset_deps.at(off.second).get(); } inline void set_branch_dep(offset_t off, branch_dep_t dep) { auto &offset_deps = branch_deps_.at(off.first); if (off.second >= offset_deps.size()) { offset_deps.resize(off.second + 1); } offset_deps[off.second] = std::move(dep); } inline void cache_expr(dfsan_label label, z3::expr const &e) { if (label != expr_cache_.size()) { // fprintf(stderr, "expected label %zu, got %u\n", // expr_cache_.size(), label); throw z3::exception("missing or adding too many expressions"); } Z3_ast ast = e; Z3_inc_ref(context_, ast); // increment reference count expr_cache_.emplace_back(ast); } inline z3::expr get_cached_expr(dfsan_label label, input_dep_set_t &deps) { if (label >= expr_cache_.size()) { throw z3::exception("invalid label"); } Z3_ast ast = expr_cache_[label]; if (ast == nullptr) { throw z3::exception("cannot find cached expression"); } deps.insert(deps_cache_[label].begin(), deps_cache_[label].end()); return z3::expr(context_, ast); } inline void dump_value_cache(dfsan_label label); z3::expr read_concrete(dfsan_label label, uint16_t size); z3::expr serialize(dfsan_label label, input_dep_set_t &deps); inline void collect_more_deps(input_dep_set_t &deps); inline size_t add_nested_constraints(input_dep_set_t &deps, z3_task_t *task); inline void save_constraint(z3::expr expr, input_dep_set_t &inputs); void construct_index_tasks(z3::expr &index, uint64_t curr, uint64_t lb, uint64_t ub, uint64_t step, z3_task_t &nested, std::vector &tasks); // String theory helpers for strchr/strstr z3::expr build_string_from_label(dfsan_label content_label, input_dep_set_t &deps); z3::expr get_byte_expr(uint32_t input, uint32_t offset, input_dep_set_t &deps); bool label_contains_indexof(dfsan_label label); }; class Z3ParserSolver : public Z3AstParser { public: Z3ParserSolver() = delete; Z3ParserSolver(void *base, size_t size, z3::context &context) : Z3AstParser(base, size, context) {} ~Z3ParserSolver() {} // Solution operation types enum class solution_op_t : uint8_t { SET, // Set byte at offset to val INSERT, // Insert bytes at offset (shifts following bytes right) DELETE // Delete len bytes starting at offset (shifts following bytes left) }; struct solution_val { solution_op_t op; uint32_t id; // input id uint32_t offset; // position in file union { uint8_t val; // for SET: the byte value uint32_t len; // for DELETE: number of bytes to delete }; std::vector data; // for INSERT: bytes to insert // Constructors for convenience // SET: set single byte at offset solution_val(uint32_t id, uint32_t offset, uint8_t val) : op(solution_op_t::SET), id(id), offset(offset), val(val) {} // INSERT: insert bytes at offset solution_val(uint32_t id, uint32_t offset, std::vector data) : op(solution_op_t::INSERT), id(id), offset(offset), data(std::move(data)) {} // DELETE: delete len bytes at offset solution_val(solution_op_t op, uint32_t id, uint32_t offset, uint32_t len) : op(op), id(id), offset(offset), len(len) {} }; enum solving_status { invalid_task = 1, opt_sat = 2, opt_unsat = 3, opt_timeout = 4, nested_sat = 5, opt_sat_nested_unsat = 6, opt_sat_nested_timeout = 7, unknown_error, }; using solution_t = std::vector; solving_status solve_task(uint64_t task_id, unsigned timeout, solution_t &solutions); private: void generate_solution(z3::model &m, solution_t &solutions); }; }; ================================================ FILE: include/parse.h ================================================ #pragma once #include "dfsan/dfsan.h" #include #include #include #include #include #include #include #include #include #include namespace symsan { using input_t = std::pair; using offset_t = std::pair; struct offset_hash { std::size_t operator()(const offset_t &off) const { uint64_t key = off.first; key <<= 32; key |= off.second; return std::hash{}(key); } }; template class ASTParser { public: ASTParser() = delete; ASTParser(void *base, size_t size) : base_(static_cast(base)), size_(size / sizeof(dfsan_label_info)), prev_task_id_(0) {} virtual ~ASTParser() {} virtual int restart(std::vector &inputs) { (void)inputs; memcmp_cache_.clear(); return 0; } /// @brief Parse a conditional branch /// @param label the label of the condition /// @param result the result of the condition /// @param add_nested whether to add nested constraints /// @param tasks the tasks to be added /// @return 0 on success, -1 on failure virtual int parse_cond(dfsan_label label, bool result, bool add_nested, std::vector &tasks) = 0; /// @brief Parse a GEP instruction with symbolic index /// @param ptr_label symbol label of the pointer (e.g., bounds info) /// @param ptr actual pointer value /// @param index_label symbolic label of the index /// @param index actual index value /// @param num_elems number of elements if ptr is an array /// @param elem_size size of each element /// @param current_offset current offset from previous GEP /// @param enum_index whether to enumerate all possible indices /// @param tasks tasks to be added /// @return 0 on success, -1 on failure virtual int parse_gep(dfsan_label ptr_label, uptr ptr, dfsan_label index_label, int64_t index, uint64_t num_elems, uint64_t elem_size, int64_t current_offset, bool enum_index, std::vector &tasks) = 0; /// @brief Add a constraint, typically from symbolic offset /// @param label symbolic label of the constraint /// @param result concrete value of the constraint /// @return 0 on success, -1 on failure virtual int add_constraints(dfsan_label label, uint64_t result) = 0; virtual int record_memcmp(dfsan_label label, uint8_t* buf, size_t size) { auto content = std::make_unique(size); memcpy(content.get(), buf, size); memcmp_cache_.insert({label, std::move(content)}); return 0; }; // use shared_ptr to auto-free task virtual std::shared_ptr retrieve_task(uint64_t id) { auto it = tasks_.find(id); if (it == tasks_.end()) { return nullptr; } auto tmp = std::move(it->second); tasks_.erase(it); return tmp; } protected: inline dfsan_label_info* get_label_info(dfsan_label label) { if (label >= size_) { throw std::out_of_range("label too large " + std::to_string(label)); } return &base_[label]; } inline uint64_t save_task(std::shared_ptr task) { uint64_t tid = prev_task_id_++; tasks_.insert({tid, task}); return tid; } dfsan_label_info *base_; size_t size_; uint64_t prev_task_id_; std::unordered_map> tasks_; std::unordered_map> memcmp_cache_; }; }; // namespace symsan ================================================ FILE: include/solver.h ================================================ #pragma once #include "task.h" #include #include #include #include #include #include #include namespace rgd { enum solver_result_t { SOLVER_ERROR, SOLVER_SAT, SOLVER_UNSAT, SOLVER_TIMEOUT, }; class Solver { public: virtual ~Solver() {}; virtual solver_result_t solve(std::shared_ptr task, const uint8_t *in_buf, size_t in_size, uint8_t *out_buf, size_t &out_size) = 0; virtual void print_stats(int fd) = 0; }; class Z3Solver : public Solver { public: Z3Solver(); solver_result_t solve(std::shared_ptr task, const uint8_t *in_buf, size_t in_size, uint8_t *out_buf, size_t &out_size) override; void print_stats(int fd) override {} ; private: z3::expr serialize_rel(uint32_t comparison, const AstNode* node, const std::vector> &input_args, std::unordered_map &expr_cache); z3::expr serialize(const AstNode* node, const std::vector> &input_args, std::unordered_map &expr_cache); z3::context &context_; z3::solver solver_; }; class JITSolver : public Solver { public: JITSolver(); solver_result_t solve(std::shared_ptr task, const uint8_t *in_buf, size_t in_size, uint8_t *out_buf, size_t &out_size) override; void print_stats(int fd) override; private: std::atomic_ulong uuid; std::atomic_ulong cache_hits; std::atomic_ulong cache_misses; std::atomic_ulong num_timeout; std::atomic_ulong num_solved; std::atomic_ulong process_time; std::atomic_ulong jit_time; std::atomic_ulong solving_time; }; class I2SSolver : public Solver { public: I2SSolver(); solver_result_t solve(std::shared_ptr task, const uint8_t *in_buf, size_t in_size, uint8_t *out_buf, size_t &out_size) override; void print_stats(int fd) override {}; private: uint64_t matches; uint64_t mismatches; std::bitset binop_mask; solver_result_t solve_icmp(std::shared_ptr const& c, std::unique_ptr const& cm, uint32_t comparison, const uint8_t *in_buf, size_t in_size, uint8_t *out_buf, size_t &out_size); solver_result_t solve_memcmp(std::shared_ptr const& c, std::unique_ptr const& cm, const uint8_t *in_buf, size_t in_size, uint8_t *out_buf, size_t &out_size); }; }; // namespace rgd ================================================ FILE: include/task.h ================================================ #pragma once #include #include #include #include #include #include #include #include #include #include "ast.h" #include "cov.h" namespace rgd { // JIT'ed function for each relational constraint typedef void(*test_fn_type)(uint64_t*); // the first two slots of the arguments for reseved for the left and right operands static const int RET_OFFSET = 2; struct Constraint { Constraint() = delete; Constraint(int ast_size): fn(nullptr), const_num(0) { ast = std::make_shared(ast_size); } Constraint(const Constraint&) = default; // XXX: okay to use default? const AstNode *get_root() const { return const_cast(ast.get()); } // JIT'ed function for a comparison expression test_fn_type fn; // the AST std::shared_ptr ast; // During constraint collection, (symbolic) input bytes are recorded // as offsets from the beginning of the input. However, the JIT'ed // function consumes inputs as an input array. So, when building the // function, we need to map the offset to the idx in input array, // which is stored in local_map. std::map local_map; // if const {false, const value}, if symbolic {true, index in the inputs} // during local search, we use a single global array (to avoid memory // allocation and free) to prepare the inputs, so we need to know where // to load the input values into the input array. std::vector> input_args; // map the offset to iv (initial value) std::unordered_map inputs; // shape information about the input (e.g., 1, 2, 4, 8 bytes) std::unordered_map shapes; // special infomation for atoi: offset -> (result_length, base, str_length) std::unordered_map> atoi_info; // record the involved operations std::bitset ops; // number of constant in the input array uint32_t const_num; // recorded comparison operands uint64_t op1, op2; }; struct ConsMeta { // per-constraint arg mapping, so we can share the constraints std::vector> input_args; // per-constraint relational operator, so we can share the AST uint32_t comparison; // input2state inference related std::vector> i2s_candidates; uint64_t op1, op2; }; class SearchTask { public: SearchTask(): scratch_args(nullptr), max_const_num_(0), stopped(false), attempts(0), solved(false), skip_next(false), base_task(nullptr) {} SearchTask(const SearchTask&) = delete; ~SearchTask() { if (scratch_args) free(scratch_args); } inline bool has_finalized() const { return scratch_args != nullptr; } using constraint_t = std::shared_ptr; using consmeta_t = std::unique_ptr; using input_t = std::pair; inline bool empty() const { return constraints_.empty(); } inline size_t size() const { return constraints_.size(); } inline void add_constraint(constraint_t constraint, uint32_t comparison) { if (has_finalized()) { throw std::runtime_error("Cannot add constraints after finalization"); } constraints_.push_back(constraint); comparisons_.push_back(comparison); } inline const constraint_t& constraints(size_t i) const { return constraints_.at(i); } inline const uint32_t comparisons(size_t i) const { return comparisons_.at(i); } inline consmeta_t& consmetas(size_t i) { // consmeta can be changed, but the vector cannot return consmetas_.at(i); } inline size_t inputs_size() const { return inputs_.size(); } inline auto const& inputs() const { return inputs_; } inline const uint32_t shapes(uint32_t offset) const { auto itr = shapes_.find(offset); if (itr == shapes_.end()) { throw std::runtime_error("Cannot find shape information"); } return itr->second; } inline auto const& atoi_info() const { return atoi_info_; } inline auto const& cmap(uint32_t index) const { if (index >= inputs_.size()) { throw std::out_of_range("index out of range"); } auto itr = cmap_.find(index); if (itr == cmap_.end()) { throw std::runtime_error("Cannot find constraint mapping"); } return itr->second; } private: // varaible that should not change after finalization // constraints, could be shared, strictly read-only std::vector constraints_; // temporary storage for the comparison operation std::vector comparisons_; // per-constraint mutable metadata std::vector consmetas_; // inputs as pairs of std::vector> inputs_; // shape information at each offset std::unordered_map shapes_; // aggreated atoi info std::unordered_map> atoi_info_; // max number of constants in the input array uint32_t max_const_num_; // record constraints that use a certain input byte std::unordered_map> cmap_; public: // scratching area for solving the task // the input array used for all JIT'ed functions // all input bytes are extended to 64 bits uint64_t* scratch_args; // intermediate states for the search std::vector min_distances; // current best std::vector distances; // general scratch std::vector plus_distances; // used in partial derivation std::vector minus_distances; // used in partial derivation // statistics uint64_t start; //start time bool stopped; int attempts; // solutions bool solved; std::unordered_map solution; // base task std::shared_ptr base_task; bool skip_next; // FIXME: an ugly hack to skip the next task void finalize() { // aggregate the contraints, map each input byte to a constraint to // an index in the "global" input array (i.e., the scratch_args) std::unordered_map sym_map; uint32_t gidx = 0; size_t num_const = constraints_.size(); for (size_t i = 0; i < num_const; i++) { auto const& constraint = constraints_[i]; std::unique_ptr cm = std::make_unique(); cm->input_args = constraint->input_args; cm->comparison = comparisons_[i]; uint32_t last_offset = -1; uint32_t size = 0; for (const auto& [offset, lidx] : constraint->local_map) { auto gitr = sym_map.find(offset); if (gitr == sym_map.end()) { gidx = inputs_.size(); sym_map[offset] = gidx; inputs_.push_back(std::make_pair(offset, constraint->inputs.at(offset))); shapes_[offset] = constraint->shapes.at(offset); } else { gidx = gitr->second; } // record input to constraint mapping // skip memcmp constraints if (cm->comparison != rgd::Memcmp && cm->comparison != rgd::MemcmpN) { auto slot = cmap_.find(gidx); if (slot != cmap_.end()) { slot->second.push_back(i); } else { cmap_.emplace(std::make_pair(gidx, std::vector{i})); } } // save the mapping between the local index (i.e., where the JIT'ed // function is going to read the input from) and the global index // (i.e., where the current value corresponding to the input byte // is stored in MutInput) cm->input_args[lidx].second = gidx; // check if the input bytes are consecutive // using std::map ensures that the offsets (keys) are sorted if (last_offset != -1 && last_offset + 1 != offset) { // a new set of consecutive input bytes, save the info // and resset cm->i2s_candidates.push_back({last_offset + 1 - size, size}); size = 0; } last_offset = offset; size++; } // save the last set of consecutive input bytes cm->i2s_candidates.push_back({last_offset + 1 - size, size}); // process atoi for (const auto& [offset, info] : constraint->atoi_info) { // check dependencies uint32_t length = std::get<2>(info); for (auto j = 0; j < length; ++j) { auto ditr = cmap_.find(offset + j); if (ditr != cmap_.end()) { fprintf(stderr, "atoi bytes (%d) used in other constraints\n", offset + j); } } auto itr = atoi_info_.find(offset); if (itr != atoi_info_.end()) { fprintf(stderr, "atoi bytes (%d) already exists\n", offset); assert(info == itr->second); } atoi_info_[offset] = info; } // update the number of required constants in the input array if (max_const_num_ < constraint->const_num) max_const_num_ = constraint->const_num; // insert the constraint metadata consmetas_.push_back(std::move(cm)); } // fill the gap in cmap_ for (size_t i = 0; i < inputs_.size(); i++) { auto slot = cmap_.find(i); if (slot == cmap_.end()) { cmap_.emplace(std::make_pair(i, std::vector{})); } } // allocate the input array, reserver 2 for comparison operands a,b scratch_args = (uint64_t*)aligned_alloc(sizeof(*scratch_args), (2 + inputs_.size() + max_const_num_ + 1) * sizeof(*scratch_args)); min_distances.resize(num_const, 0); distances.resize(num_const, 0); plus_distances.resize(num_const, 0); minus_distances.resize(num_const, 0); } void load_hint() { // load hint from base task if (!base_task || !base_task->solved) return; for (auto itr = inputs_.begin(), e = inputs_.end(); itr != e; itr++) { auto got = base_task->solution.find(itr->first); if (got != base_task->solution.end()) itr->second = got->second; } } }; using task_t = std::shared_ptr; }; // namespace rgd ================================================ FILE: include/task_mgr.h ================================================ #pragma once #include "task.h" #include #include namespace rgd { class TaskManager { public: virtual ~TaskManager() {} virtual bool add_task(std::shared_ptr ctx, std::shared_ptr task) = 0; virtual std::shared_ptr get_next_task() = 0; virtual size_t get_num_tasks() = 0; }; class FIFOTaskManager : public TaskManager { public: bool add_task(std::shared_ptr ctx, std::shared_ptr task) override { (void)ctx; tasks.push_back(std::move(task)); return true; } std::shared_ptr get_next_task() override { if (tasks.empty()) return nullptr; auto task = std::move(tasks.front()); tasks.pop_front(); return task; } size_t get_num_tasks() override { return tasks.size(); } private: std::deque tasks; }; }; // namespace rgd ================================================ FILE: include/union_find.h ================================================ #pragma once #include #include #include namespace rgd { // disjoint set data structure class UnionFind { public: static const size_t INVALID = (size_t)-1; UnionFind() : size_(0) {}; UnionFind(size_t size) { reset(size); }; void reset(size_t size) { size_ = size; parent.resize(size); next.resize(size); rank.resize(size); for (size_t i = 0; i < size; ++i) { parent[i] = i; next[i] = i; rank[i] = 0; } } // find the root of the set containing x size_t find(size_t x) { if (x >= size_) return INVALID; size_t p = parent[x]; while (x != p) { size_t gp = parent[p]; parent[x] = gp; x = p; p = gp; } return x; } // merge the sets containing x and y, return new root size_t merge(size_t x, size_t y) { if (x >= size_) return INVALID; if (y >= size_) return INVALID; size_t x_root = find(x); size_t y_root = find(y); if (x_root == y_root) return x_root; // merge link list size_t x_next = next[x_root]; next[x_root] = next[y_root]; next[y_root] = x_next; if (rank[x_root] < rank[y_root]) { parent[x_root] = y_root; return y_root; } else if (rank[x_root] > rank[y_root]) { parent[y_root] = x_root; return x_root; } else { parent[y_root] = x_root; rank[x_root]++; return x_root; } } // get the set containing x size_t get_set(size_t x, std::unordered_set &set) { if (x >= size_) return INVALID; size_t temp = x; set.clear(); set.insert(temp); while (next[temp] != x) { temp = next[temp]; set.insert(temp); } return set.size(); } private: size_t size_; std::vector parent; std::vector next; std::vector rank; }; }; ================================================ FILE: include/version.h ================================================ #ifndef _ANGORA_LLVM_VERSION_H #define _ANGORA_LLVM_VERSION_H #define LLVM_VERSION(major, minor) ((major)*100 + (minor)) #define LLVM_VERSION_CODE LLVM_VERSION(LLVM_VERSION_MAJOR, LLVM_VERSION_MINOR) #if LLVM_VERSION_CODE >= LLVM_VERSION(5, 0) #define LLVM_ATTRIBUTE_LIST AttributeList #define LLVM_NEW_ALLOCINST(ty, name, insertp) \ (new AllocaInst(ty, getDataLayout().getAllocaAddrSpace(), name, insertp)) #define LLVM_REMOVE_ATTRIBUTE(func, attr, attrbuilder) \ func->removeAttributes(attr, attrbuilder) #else #define LLVM_ATTRIBUTE_LIST AttributeSet #define LLVM_NEW_ALLOCINST(ty, name, insertp) \ (new AllocaInst(ty, name, insertp)) #define LLVM_REMOVE_ATTRIBUTE(func, attr, attrbuilder) \ func->removeAttributes( \ attr, LLVM_ATTRIBUTE_LIST::get(func->getContext(), attr, attrbuilder)) #endif #if LLVM_VERSION_CODE >= LLVM_VERSION(6, 0) #define SCL_INSECTION(scl, section, prefix, query, category) \ scl->inSection(section, prefix, query, category) #define LLVM_ADD_PARAM_ATTR(func, argno, attr) func->addParamAttr(argno, attr) #else #define SCL_INSECTION(scl, section, prefix, query, category) \ scl->inSection(prefix, query, category) #define LLVM_ADD_PARAM_ATTR(func, argno, attr) \ func->addAttribute(argno + 1, attr) #endif #endif ================================================ FILE: instrumentation/CMakeLists.txt ================================================ set (CMAKE_CXX_STANDARD 14) set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g") # fix pass bug: https://github.com/sampsyo/llvm-pass-skeleton/issues/7#issuecomment-401834287 set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_CXX_LINK_FLAGS} -Wl,-znodelete") if(APPLE) # User teor2345 reports that this is required to make things work on MacOS X. set (CMAKE_MODULE_LINK_FLAGS "${CMAKE_CXX_LINK_FLAGS} -Wl,-flat_namespace -Wl,-undefined,suppress") endif(APPLE) include(AddLLVM) add_llvm_pass_plugin(TaintPass TaintPass.cpp) install (TARGETS TaintPass DESTINATION ${SYMSAN_LIB_DIR}) ================================================ FILE: instrumentation/TaintPass.cpp ================================================ //===- Taint.cpp - dynamic taint analysis --------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // /// \file /// This file is a part of Taint, a specialized taint analysis for symbolic /// execution. // //===----------------------------------------------------------------------===// //#include "defs.h" #include "version.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseSet.h" #include "llvm/ADT/DepthFirstIterator.h" #include "llvm/ADT/None.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/Triple.h" #include "llvm/ADT/iterator.h" #include "llvm/Analysis/ValueTracking.h" #include "llvm/IR/Argument.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/BasicBlock.h" #include "llvm/IR/Constant.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DataLayout.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Dominators.h" #include "llvm/IR/Function.h" #include "llvm/IR/GlobalAlias.h" #include "llvm/IR/GlobalValue.h" #include "llvm/IR/GlobalVariable.h" #include "llvm/IR/IRBuilder.h" #include "llvm/IR/InlineAsm.h" #include "llvm/IR/InstVisitor.h" #include "llvm/IR/InstrTypes.h" #include "llvm/IR/Instruction.h" #include "llvm/IR/Instructions.h" #include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/LLVMContext.h" #include "llvm/IR/LegacyPassManager.h" #include "llvm/IR/MDBuilder.h" #include "llvm/IR/Module.h" #include "llvm/IR/PassManager.h" #include "llvm/IR/Type.h" #include "llvm/IR/User.h" #include "llvm/IR/Value.h" #include "llvm/InitializePasses.h" #include "llvm/Pass.h" #include "llvm/Passes/OptimizationLevel.h" #include "llvm/Passes/PassBuilder.h" #include "llvm/Passes/PassPlugin.h" #include "llvm/Support/Alignment.h" #include "llvm/Support/Casting.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/DJB.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/SpecialCaseList.h" #include "llvm/Support/VirtualFileSystem.h" #include "llvm/Transforms/Instrumentation.h" #include "llvm/Transforms/IPO/PassManagerBuilder.h" #include "llvm/Transforms/Utils/BasicBlockUtils.h" #include "llvm/Transforms/Utils/Local.h" #include #include #include #include #include #include #include #include #include #include #include using namespace llvm; // This must be consistent with ShadowWidthBits. static const Align ShadowTLSAlignment = Align(4); // The size of TLS variables. These constants must be kept in sync with the ones // in dfsan.cpp. static const unsigned ArgTLSSize = 800; static const unsigned RetvalTLSSize = 800; // The -taint-preserve-alignment flag controls whether this pass assumes that // alignment requirements provided by the input IR are correct. For example, // if the input IR contains a load with alignment 8, this flag will cause // the shadow load to have alignment 16. This flag is disabled by default as // we have unfortunately encountered too much code (including Clang itself; // see PR14291) which performs misaligned access. static cl::opt ClPreserveAlignment( "taint-preserve-alignment", cl::desc("respect alignment requirements provided by input IR"), cl::Hidden, cl::init(false)); // The ABI list files control how shadow parameters are passed. The pass treats // every function labelled "uninstrumented" in the ABI list file as conforming // to the "native" (i.e. unsanitized) ABI. Unless the ABI list contains // additional annotations for those functions, a call to one of those functions // will produce a warning message, as the labelling behaviour of the function is // unknown. The other supported annotations for uninstrumented functions are // "functional" and "discard", which are described below under // Taint::WrapperKind. // Functions will often be labelled with both "uninstrumented" and one of // "functional" or "discard". This will leave the function unchanged by this // pass, and create a wrapper function that will call the original. // // Instrumented functions can also be annotated as "force_zero_labels", which // will make all shadow and return values set zero labels. // Functions should never be labelled with both "force_zero_labels" and // "uninstrumented" or any of the unistrumented wrapper kinds. static cl::list ClABIListFiles( "taint-abilist", cl::desc("File listing native ABI functions and how the pass treats them"), cl::Hidden); // Controls whether the pass includes or ignores the labels of pointers in load // instructions. static cl::opt ClCombinePointerLabelsOnLoad( "taint-combine-pointer-labels-on-load", cl::desc("Combine the label of the pointer with the label of the data when " "loading from memory."), cl::Hidden, cl::init(false)); // Controls whether the pass includes or ignores the labels of pointers in // stores instructions. static cl::opt ClCombinePointerLabelsOnStore( "taint-combine-pointer-labels-on-store", cl::desc("Combine the label of the pointer with the label of the data when " "storing in memory."), cl::Hidden, cl::init(false)); static cl::opt ClDebugNonzeroLabels( "taint-debug-nonzero-labels", cl::desc("Insert calls to __dfsan_nonzero_label on observing a parameter, " "load or return with a nonzero label"), cl::Hidden); static cl::opt ClIgnorePersonalityRoutine( "taint-ignore-personality-routine", cl::desc("If a personality routine is marked uninstrumented from the ABI " "list, do not create a wrapper for it."), cl::Hidden, cl::init(false)); // SYMSAN specific flags, invoke a callback function to trace GEP events static cl::opt ClTraceGEPOffset( "taint-trace-gep", cl::desc("Trace GEP offset for solving."), cl::Hidden, cl::init(true)); // Experimental feature, trace floating point operations static cl::opt ClTraceFP( "taint-trace-float-pointer", cl::desc("Propagate taint for floating pointer instructions."), cl::Hidden, cl::init(false)); static cl::opt ClTraceLoop( "taint-trace-loop", cl::desc("Trace loop entering and exiting."), cl::Hidden, cl::init(true)); // SYMSAN specific flags, enable memory safety checks (both spatial and temporal) static cl::opt ClTraceBound( "taint-trace-bound", cl::desc("Trace buffer bound info."), cl::Hidden, cl::init(true)); // SYMSAN specific flags, enable generating solving tasks for undefined behaviour static cl::opt ClSolveUB( "taint-solve-ub", cl::desc("Solve undefined behaviours."), cl::Hidden, cl::init(false)); // SYMSAN specific flags, only send events for annotated basic blocks static cl::opt ClTraceAnnotatedBB( "taint-trace-annotated-bb", cl::desc("Only trace annotated basic blocks."), cl::Hidden, cl::init(false)); static StringRef getGlobalTypeString(const GlobalValue &G) { // Types of GlobalVariables are always pointer types. Type *GType = G.getValueType(); // For now we support excluding struct types only. if (StructType *SGType = dyn_cast(GType)) { if (!SGType->isLiteral()) return SGType->getName(); } return ""; } namespace { // Memory map parameters used in application-to-shadow address calculation. // Offset = (Addr & ~AndMask) ^ XorMask // Shadow = ShadowBase + Offset * ShadowWidthBytes struct MemoryMapParams { uint64_t AndMask; uint64_t XorMask; uint64_t ShadowBase; }; } // end anonymous namespace // x86_64 Linux // NOLINTNEXTLINE(readability-identifier-naming) static const MemoryMapParams Linux_X86_64_MemoryMapParams = { 0x700000000000, // AndMask (keep old style) 0, // XorMask (not used) 0, // ShadowBase (not used) }; namespace { class TaintABIList { std::unique_ptr SCL; public: TaintABIList() = default; void set(std::unique_ptr List) { SCL = std::move(List); } /// Returns whether either this function or its source file are listed in the /// given category. bool isIn(const Function &F, StringRef Category) const { return isIn(*F.getParent(), Category) || SCL->inSection("taint", "fun", F.getName(), Category); } /// Returns whether this global alias is listed in the given category. /// /// If GA aliases a function, the alias's name is matched as a function name /// would be. Similarly, aliases of globals are matched like globals. bool isIn(const GlobalAlias &GA, StringRef Category) const { if (isIn(*GA.getParent(), Category)) return true; if (isa(GA.getValueType())) return SCL->inSection("taint", "fun", GA.getName(), Category); return SCL->inSection("taint", "global", GA.getName(), Category) || SCL->inSection("dataflow", "type", getGlobalTypeString(GA), Category); } /// Returns whether this module is listed in the given category. bool isIn(const Module &M, StringRef Category) const { return SCL->inSection("taint", "src", M.getModuleIdentifier(), Category); } }; /// TransformedFunction is used to express the result of transforming one /// function type into another. This struct is immutable. It holds metadata /// useful for updating calls of the old function to the new type. struct TransformedFunction { TransformedFunction(FunctionType* OriginalType, FunctionType* TransformedType, std::vector ArgumentIndexMapping) : OriginalType(OriginalType), TransformedType(TransformedType), ArgumentIndexMapping(ArgumentIndexMapping) {} // Disallow copies. TransformedFunction(const TransformedFunction &) = delete; TransformedFunction &operator=(const TransformedFunction &) = delete; // Allow moves. TransformedFunction(TransformedFunction &&) = default; TransformedFunction &operator=(TransformedFunction &&) = default; /// Type of the function before the transformation. FunctionType *OriginalType; /// Type of the function after the transformation. FunctionType *TransformedType; /// Transforming a function may change the position of arguments. This /// member records the mapping from each argument's old position to its new /// position. Argument positions are zero-indexed. If the transformation /// from F to F' made the first argument of F into the third argument of F', /// then ArgumentIndexMapping[0] will equal 2. std::vector ArgumentIndexMapping; }; /// Given function attributes from a call site for the original function, /// return function attributes appropriate for a call to the transformed /// function. AttributeList TransformFunctionAttributes(const TransformedFunction& TransformedFunction, LLVMContext& Ctx, AttributeList CallSiteAttrs) { // Construct a vector of AttributeSet for each function argument. std::vector ArgumentAttributes( TransformedFunction.TransformedType->getNumParams()); // Copy attributes from the parameter of the original function to the // transformed version. 'ArgumentIndexMapping' holds the mapping from // old argument position to new. for (unsigned I = 0, IE = TransformedFunction.ArgumentIndexMapping.size(); I < IE; ++I) { unsigned TransformedIndex = TransformedFunction.ArgumentIndexMapping[I]; ArgumentAttributes[TransformedIndex] = CallSiteAttrs.getParamAttrs(I); } // Copy annotations on varargs arguments. for (unsigned I = TransformedFunction.OriginalType->getNumParams(), IE = CallSiteAttrs.getNumAttrSets(); I < IE; ++I) { ArgumentAttributes.push_back(CallSiteAttrs.getParamAttrs(I)); } return AttributeList::get(Ctx, CallSiteAttrs.getFnAttrs(), CallSiteAttrs.getRetAttrs(), llvm::makeArrayRef(ArgumentAttributes)); } class Taint { friend struct TaintFunction; friend class TaintVisitor; enum { ShadowWidthBits = 32, ShadowWidthBytes = ShadowWidthBits / 8 }; /// How should calls to uninstrumented functions be handled? enum WrapperKind { /// This function is present in an uninstrumented form but we don't know /// how it should be handled. Print a warning and call the function anyway. /// Don't label the return value. WK_Warning, /// This function does not write to (user-accessible) memory, and its return /// value is unlabelled. WK_Discard, /// This function does not write to (user-accessible) memory, and the label /// of its return value is the union of the label of its arguments. WK_Functional, /// Instead of calling the function, a custom wrapper __dfsw_F is called, /// where F is the name of the function. This function may wrap the /// original function or provide its own implementation. This is similar to /// the IA_Args ABI, except that IA_Args uses a struct return type to /// pass the return value shadow in a register, while WK_Custom uses an /// extra pointer argument to return the shadow. This allows the wrapped /// form of the function type to be expressed in C. WK_Custom, /// Special cases for memcmp, strcmp, strncmp like functions WK_Memcmp, WK_Strcmp, WK_Strncmp, WK_Strchr, // strchr/memchr - find first char occurrence WK_Strrchr, // strrchr/memrchr - find last char occurrence WK_Strstr, // strstr/memmem - find substring WK_Prefixof, // prefix check (e.g., g_str_has_prefix) WK_Suffixof, // suffix check (e.g., g_str_has_suffix) WK_Strcat, // strcat/strncat - string concatenation WK_Strsub, // substr(s, start, len) - substring from start with len }; Module *Mod; LLVMContext *Ctx; IntegerType *Int8Ty; IntegerType *Int16Ty; IntegerType *Int32Ty; IntegerType *Int64Ty; /// The shadow type for all primitive types and vector types. IntegerType *PrimitiveShadowTy; PointerType *PrimitiveShadowPtrTy; IntegerType *IntptrTy; PointerType *VoidPtrTy; ConstantInt *ZeroPrimitiveShadow; ConstantInt *UninitializedPrimitiveShadow; ConstantInt *ShadowPtrAndMask; ConstantInt *ShadowPtrXorMask; ConstantInt *ShadowPtrBase; ConstantInt *ShadowPtrMul; Constant *ArgTLS; Constant *RetvalTLS; FunctionType *TaintUnionFnTy; FunctionType *TaintUnionLoadFnTy; FunctionType *TaintUnionStoreFnTy; FunctionType *TaintUnimplementedFnTy; FunctionType *TaintSetLabelFnTy; FunctionType *TaintNonzeroLabelFnTy; FunctionType *TaintVarargWrapperFnTy; FunctionType *TaintTraceCmpFnTy; FunctionType *TaintTraceCondFnTy; FunctionType *TaintTraceLoopFnTy; FunctionType *TaintTraceSwitchEndFnTy; FunctionType *TaintTraceSelectFnTy; FunctionType *TaintTraceIndirectCallFnTy; FunctionType *TaintTraceGEPFnTy; FunctionType *TaintTraceGEPPtrFnTy; FunctionType *TaintPushStackFrameFnTy; FunctionType *TaintPopStackFrameFnTy; FunctionType *TaintTraceAllocaFnTy; FunctionType *TaintCheckBoundsFnTy; FunctionType *TaintSolveBoundsFnTy; FunctionType *TaintSolveSizeFnTy; FunctionType *TaintTraceGlobalFnTy; FunctionType *TaintDebugFnTy; FunctionCallee TaintUnionFn; FunctionCallee TaintCheckedUnionFn; FunctionCallee TaintUnionLoadFn; FunctionCallee TaintUnionStoreFn; FunctionCallee TaintUnimplementedFn; FunctionCallee TaintSetLabelFn; FunctionCallee TaintNonzeroLabelFn; FunctionCallee TaintVarargWrapperFn; FunctionCallee TaintTraceCmpFn; FunctionCallee TaintTraceCondFn; FunctionCallee TaintTraceLoopFn; FunctionCallee TaintTraceSwitchEndFn; FunctionCallee TaintTraceSelectFn; FunctionCallee TaintTraceIndirectCallFn; FunctionCallee TaintTraceGEPFn; FunctionCallee TaintTraceGEPPtrFn; FunctionCallee TaintPushStackFrameFn; FunctionCallee TaintPopStackFrameFn; FunctionCallee TaintTraceAllocaFn; FunctionCallee TaintCheckBoundsFn; FunctionCallee TaintSolveBoundsFn; FunctionCallee TaintSolveSizeFn; FunctionCallee TaintTraceGlobalFn; FunctionCallee TaintDebugFn; SmallPtrSet TaintRuntimeFunctions; Constant *CallStack; MDNode *ColdCallWeights; TaintABIList ABIList; DenseMap UnwrappedFnMap; AttributeMask ReadOnlyNoneAttrs; /// Memory map parameters used in calculation mapping application addresses /// to shadow addresses and origin addresses. const MemoryMapParams *MapParams; Value *getShadowOffset(Value *Addr, IRBuilder<> &IRB); Value *getShadowAddress(Value *Addr, IRBuilder<> &IRB); bool isInstrumented(const Function *F); bool isInstrumented(const GlobalAlias *GA); FunctionType *getArgsFunctionType(FunctionType *T); bool isForceZeroLabels(const Function *F); FunctionType *getTrampolineFunctionType(FunctionType *T); TransformedFunction getCustomFunctionType(FunctionType *T); WrapperKind getWrapperKind(Function *F); void addGlobalNameSuffix(GlobalValue *GV); Function *buildWrapperFunction(Function *F, StringRef NewFName, GlobalValue::LinkageTypes NewFLink, FunctionType *NewFT); Constant *getOrBuildTrampolineFunction(FunctionType *FT, StringRef FName); void addContextRecording(Function &F); void addFrameTracing(Function &F); uint32_t getInstructionId(Instruction *Inst); const uint32_t InvalidInstructionId = -1; void initializeRuntimeFunctions(Module &M); void initializeCallbackFunctions(Module &M); bool initializeModule(Module &M); /// Returns a zero constant with the shadow type of OrigTy. /// /// getZeroShadow({T1,T2,...}) = {getZeroShadow(T1),getZeroShadow(T2,...} /// getZeroShadow([n x T]) = [n x getZeroShadow(T)] /// getZeroShadow(other type) = i16(0) /// /// Note that a zero shadow is always i16(0) when shouldTrackFieldsAndIndices /// returns false. Constant *getZeroShadow(Type *OrigTy); /// Returns a zero constant with the shadow type of V's type. Constant *getZeroShadow(Value *V); /// Checks if V is a zero shadow. bool isZeroShadow(Value *V); /// Returns the shadow type of OrigTy. /// /// getShadowTy({T1,T2,...}) = {getShadowTy(T1),getShadowTy(T2),...} /// getShadowTy([n x T]) = [n x getShadowTy(T)] /// getShadowTy(other type) = i16 /// /// Note that a shadow type is always i16 when shouldTrackFieldsAndIndices /// returns false. Type *getShadowTy(Type *OrigTy); /// Returns the shadow type of of V's type. Type *getShadowTy(Value *V); /// Returns an uninitialized shadow value with the shadow type of OrigTy. Constant *getUninitializedShadow(Type *OrigTy); public: Taint(const std::vector &ABIListFiles); bool runImpl(Module &M); }; struct TaintFunction { Taint &TT; Function *F; DominatorTree DT; LoopInfo *LI; bool IsNativeABI; bool IsForceZeroLabels; Value *ArgTLSPtr = nullptr; Value *RetvalTLSPtr = nullptr; AllocaInst *LabelReturnAlloca = nullptr; DenseMap ValShadowMap; DenseMap AllocaShadowMap; struct PHIFixupElement { PHINode *Phi; PHINode *ShadowPhi; }; std::vector PHIFixups; DenseSet SkipInsts; std::vector NonZeroChecks; bool AvoidNewBlocks; std::hash HashFn; struct CachedShadow { BasicBlock *Block; // The block where Shadow is defined. Value *Shadow; }; /// Maps a value to its latest shadow value in terms of domination tree. DenseMap, CachedShadow> CachedShadows; /// Maps a value to its latest collapsed shadow value it was converted to in /// terms of domination tree. When ClDebugNonzeroLabels is on, this cache is /// used at a post process where CFG blocks are split. So it does not cache /// BasicBlock like CachedShadows, but uses domination between values. DenseMap CachedCollapsedShadows; DenseMap> ShadowElements; TaintFunction(Taint &TT, Function *F, bool IsNativeABI, bool IsForceZeroLabels) : TT(TT), F(F), IsNativeABI(IsNativeABI), IsForceZeroLabels(IsForceZeroLabels) { DT.recalculate(*F); LI = new LoopInfo(DT); // initialize the pseudo-random number generator with the function name srandom(std::hash{}(F->getName().str())); } ~TaintFunction() { delete LI; } /// Computes the shadow address for a given function argument. /// /// Shadow = ArgTLS+ArgOffset. Value *getArgTLS(Type *T, unsigned ArgOffset, IRBuilder<> &IRB); /// Computes the shadow address for a retval. Value *getRetvalTLS(Type *T, IRBuilder<> &IRB); Value *getShadow(Value *V); void setShadow(Instruction *I, Value *Shadow); /// Returns the shadow value of a global variable GV. Value *getShadowForGlobal(GlobalVariable *GV, IRBuilder<> &IRB); // Op Shadow Value *combineShadows(Value *V1, Value *V2, uint16_t op, Instruction *Pos); Value *combineBinaryOperatorShadows(BinaryOperator *BO, uint8_t op); Value *combineCastInstShadows(CastInst *CI, uint8_t op); Value *combineCmpInstShadows(CmpInst *CI, uint8_t op); void visitCmpInst(CmpInst *I); void visitCondition(Value *Cond, Instruction *I); void visitSwitchInst(SwitchInst *I); Value *visitSelectInst(Value *Cond, Value *TS, Value *FS, SelectInst *I); void visitGEPInst(GetElementPtrInst *I); Value *visitAllocaInst(AllocaInst *I, Value *ArraySize, Type *ElTy); void checkBounds(Value *Ptr, Value *Size, Instruction *Pos); void solveBounds(Value *Ptr, Value *Size, Instruction *Pos); /// XXX: because we never collapse taint labels for aggregate types, /// we also do not expand taint labels from an aggreated primitive /// shadow value. Instead, we always load the label for each /// primitive field. /// /// Load all primitive subtypes of T, returning the aggrate shadow value. /// /// LS({T1,T2, ...}, Addr) = {LS(T1, SubAdrr),LS(T2, SubAddr),...} /// LS([n x T], Addr) = [n x LS(T, SubAddr)] /// LS(other types, Addr) = LS(PS, Addr) Value *loadShadow(Type *T, Value *Addr, uint64_t Size, Align Alignment, Instruction *Pos); /// XXX: we do not union taint labels for aggregate types before store; /// instead, we store each privimitive field individually. /// /// Store all primitive subtypes of T, using the aggrate shadow value. /// /// SS(Addr, {T1,T2, ...}) = SS(SubAddr, T1), SS(SubAddr, T2), ... /// SS(Addr, [T1,T2,...]) = SS(SubAddr, T1), SS(SubAddr, T2), ... /// SS(Addr, PS) = SS(Addr, PS) void storeShadow(Value *Addr, Type *T, uint64_t Size, Align Alignment, Value *Shadow, Instruction *Pos); Align getShadowAlign(Align InstAlignment); private: /// Loads a primitive shadow label Value *loadPrimitiveShadow(Value *Addr, uint64_t Size, uint64_t Align, IRBuilder<> &IRB); /// Loads shadow recursively for aggregate types void loadShadowRecursive(Value *Shadow, SmallVector &Indices, Type *SubTy, Value *Addr, uint64_t Size, uint64_t Align, IRBuilder<> &IRB); /// Stores an aggregate shadow label void storeShadowRecursive(Value *Shadow, SmallVector &Indices, Type *SubShadowTy, Value *ShadowAddr, uint64_t Size, uint64_t Align, IRBuilder<> &IRB); /// Returns the shadow value of an argument A. Value *getShadowForTLSArgument(Argument *A); static const uint8_t TrueBranchLoopLatch = 0x8; static const uint8_t FalseBranchLoopLatch = 0x4; static const uint8_t TrueBranchLoopExit = 0x2; static const uint8_t FalseBranchLoopExit = 0x1; static const uint8_t LoopExitBranch = TrueBranchLoopExit | FalseBranchLoopExit; }; class TaintVisitor : public InstVisitor { public: TaintFunction &TF; TaintVisitor(TaintFunction &TF) : TF(TF) {} const DataLayout &getDataLayout() const { return TF.F->getParent()->getDataLayout(); } //void visitUnaryOperator(UnaryOperator &UO); void visitBinaryOperator(BinaryOperator &BO); void visitCastInst(CastInst &CI); void visitCmpInst(CmpInst &CI); void visitLandingPadInst(LandingPadInst &LPI); void visitGetElementPtrInst(GetElementPtrInst &GEPI); void visitLoadInst(LoadInst &LI); void visitStoreInst(StoreInst &SI); void visitAtomicRMWInst(AtomicRMWInst &I); //void visitAtomicCmpXchgInst(AtomicCmpXchgInst &I); void visitReturnInst(ReturnInst &RI); void visitCallBase(CallBase &CB); void visitPHINode(PHINode &PN); void visitExtractElementInst(ExtractElementInst &I); void visitInsertElementInst(InsertElementInst &I); void visitShuffleVectorInst(ShuffleVectorInst &I); void visitExtractValueInst(ExtractValueInst &I); void visitInsertValueInst(InsertValueInst &I); void visitAllocaInst(AllocaInst &I); void visitSelectInst(SelectInst &I); void visitMemSetInst(MemSetInst &I); void visitMemTransferInst(MemTransferInst &I); void visitBranchInst(BranchInst &BR); void visitSwitchInst(SwitchInst &SW); private: //void visitCASOrRMW(Align InstAlignment, Instruction &I); // Returns false when this is an invoke of a custom function. bool visitWrappedCallBase(Function *F, CallBase &CB); void addShadowArguments(Function *F, CallBase &CB, std::vector &Args, IRBuilder<> &IRB); void visitIntrinsicCallBase(Function *F, CallBase &CB); }; } // end anonymous namespace Taint::Taint( const std::vector &ABIListFiles) { std::vector AllABIListFiles(std::move(ABIListFiles)); llvm::append_range(AllABIListFiles, ClABIListFiles); // FIXME: should we propagate vfs::FileSystem to this constructor? ABIList.set( SpecialCaseList::createOrDie(AllABIListFiles, *vfs::getRealFileSystem())); } FunctionType *Taint::getArgsFunctionType(FunctionType *T) { SmallVector ArgTypes(T->param_begin(), T->param_end()); // we keep the shadow type consistent with the arg type so we don't // need to collapse or expand the shadow for (unsigned i = 0, ie = T->getNumParams(); i != ie; ++i) { Type* param_type = T->getParamType(i); ArgTypes.push_back(getShadowTy(param_type)); } // ArgTypes.append(T->getNumParams(), PrimitiveShadowTy); if (T->isVarArg()) // FIXME: vararg ArgTypes.push_back(PrimitiveShadowPtrTy); Type *RetType = T->getReturnType(); if (!RetType->isVoidTy()) RetType = StructType::get(RetType, getShadowTy(RetType)); return FunctionType::get(RetType, ArgTypes, T->isVarArg()); } FunctionType *Taint::getTrampolineFunctionType(FunctionType *T) { assert(!T->isVarArg()); SmallVector ArgTypes; ArgTypes.push_back(T->getPointerTo()); ArgTypes.append(T->param_begin(), T->param_end()); // we keep the shadow type consistent with the arg type so we don't // need to collapse or expand the shadow for (unsigned i = 0, ie = T->getNumParams(); i != ie; ++i) { Type* param_type = T->getParamType(i); ArgTypes.push_back(getShadowTy(param_type)); } // ArgTypes.append(T->getNumParams(), PrimitiveShadowTy); Type *RetType = T->getReturnType(); if (!RetType->isVoidTy()) // ArgTypes.push_back(PrimitiveShadowPtrTy); ArgTypes.push_back(PointerType::getUnqual(getShadowTy(RetType))); return FunctionType::get(T->getReturnType(), ArgTypes, false); } TransformedFunction Taint::getCustomFunctionType(FunctionType *T) { SmallVector ArgTypes; // Some parameters of the custom function being constructed are // parameters of T. Record the mapping from parameters of T to // parameters of the custom function, so that parameter attributes // at call sites can be updated. std::vector ArgumentIndexMapping; for (unsigned I = 0, E = T->getNumParams(); I != E; ++I) { Type* ParamType = T->getParamType(I); FunctionType *FT; if (isa(ParamType) && (FT = dyn_cast(ParamType->getPointerElementType()))) { ArgumentIndexMapping.push_back(ArgTypes.size()); ArgTypes.push_back(getTrampolineFunctionType(FT)->getPointerTo()); ArgTypes.push_back(Type::getInt8PtrTy(*Ctx)); } else { ArgumentIndexMapping.push_back(ArgTypes.size()); ArgTypes.push_back(ParamType); } } for (unsigned i = 0, e = T->getNumParams(); i != e; ++i) { // we keep the shadow type consistent with the arg type so we don't // need to collapse or expand the shadow Type* param_type = T->getParamType(i); ArgTypes.push_back(getShadowTy(param_type)); // ArgTypes.push_back(PrimitiveShadowTy); } if (T->isVarArg()) // FIXME: vararg ArgTypes.push_back(PrimitiveShadowPtrTy); Type *RetType = T->getReturnType(); if (!RetType->isVoidTy()) ArgTypes.push_back(PointerType::getUnqual(getShadowTy(RetType))); // ArgTypes.push_back(PrimitiveShadowPtrTy); return TransformedFunction( T, FunctionType::get(T->getReturnType(), ArgTypes, T->isVarArg()), ArgumentIndexMapping); } bool Taint::isZeroShadow(Value *V) { Type *T = V->getType(); if (!isa(T) && !isa(T)) { if (const ConstantInt *CI = dyn_cast(V)) return CI->isZero(); return false; } return isa(V); } Constant *Taint::getUninitializedShadow(Type *OrigTy) { if (!isa(OrigTy) && !isa(OrigTy)) return UninitializedPrimitiveShadow; Type *ShadowTy = getShadowTy(OrigTy); if (ArrayType *AT = dyn_cast(ShadowTy)) { SmallVector Elements(AT->getNumElements(), getUninitializedShadow(AT->getElementType())); return ConstantArray::get(AT, Elements); } else if (StructType *ST = dyn_cast(ShadowTy)) { SmallVector Elements(ST->getNumElements()); for (unsigned I = 0, N = ST->getNumElements(); I < N; ++I) Elements[I] = getUninitializedShadow(ST->getElementType(I)); return ConstantStruct::get(ST, Elements); } llvm_unreachable("Unexpected type for uninitialized shadow"); } Constant *Taint::getZeroShadow(Type *OrigTy) { if (!isa(OrigTy) && !isa(OrigTy)) return ZeroPrimitiveShadow; Type *ShadowTy = getShadowTy(OrigTy); return ConstantAggregateZero::get(ShadowTy); } Constant *Taint::getZeroShadow(Value *V) { return getZeroShadow(V->getType()); } Type *Taint::getShadowTy(Type *OrigTy) { if (!OrigTy->isSized()) return PrimitiveShadowTy; if (isa(OrigTy)) return PrimitiveShadowTy; if (isa(OrigTy)) return PrimitiveShadowTy; if (ArrayType *AT = dyn_cast(OrigTy)) return ArrayType::get(getShadowTy(AT->getElementType()), AT->getNumElements()); if (StructType *ST = dyn_cast(OrigTy)) { SmallVector Elements; for (unsigned I = 0, N = ST->getNumElements(); I < N; ++I) Elements.push_back(getShadowTy(ST->getElementType(I))); return StructType::get(*Ctx, Elements); } return PrimitiveShadowTy; } Type *Taint::getShadowTy(Value *V) { return getShadowTy(V->getType()); } uint32_t Taint::getInstructionId(Instruction *Inst) { // check if there is a bbid annotation if (MDNode *BBID = Inst->getMetadata("bbid")) { auto C = dyn_cast(BBID->getOperand(0)); if (ConstantInt *CI = dyn_cast(C->getValue())) { uint64_t BBIDValue = CI->getZExtValue(); assert(BBIDValue < UINT32_MAX && "bbid value is too large for 32-bit hash"); return static_cast(BBIDValue); } } if (ClTraceAnnotatedBB && Inst->isTerminator()) return InvalidInstructionId; // otherwise, fallback to hash static uint32_t unamed = 0; auto SourceInfo = Mod->getSourceFileName(); DILocation *Loc = Inst->getDebugLoc(); if (Loc) { auto Line = Loc->getLine(); auto Col = Loc->getColumn(); SourceInfo += ":" + std::to_string(Line) + ":" + std::to_string(Col); } else { SourceInfo += "unamed:" + std::to_string(unamed++); } return djbHash(SourceInfo); } void Taint::addContextRecording(Function &F) { // Most code from Angora BasicBlock *BB = &F.getEntryBlock(); assert(pred_begin(BB) == pred_end(BB) && "Assume that entry block has no predecessors"); // Add ctx ^ hash(fun_name) at the beginning of a function IRBuilder<> IRB(&*(BB->getFirstInsertionPt())); // Strip dfs$ prefix auto FName = F.getName(); if (FName.startswith("dfs")) { size_t pos = FName.find_first_of('$'); FName = FName.drop_front(pos + 1); } // add source file name for static function if (!F.hasExternalLinkage()) { FName = StringRef(Mod->getSourceFileName() + "::" + FName.str()); } uint32_t hash = djbHash(FName); ConstantInt *CID = ConstantInt::get(Int32Ty, hash); LoadInst *LCS = IRB.CreateLoad(Int32Ty, CallStack); LCS->setMetadata(Mod->getMDKindID("nosanitize"), MDNode::get(*Ctx, None)); Value *NCS = IRB.CreateXor(LCS, CID); StoreInst *SCS = IRB.CreateStore(NCS, CallStack); SCS->setMetadata(Mod->getMDKindID("nosanitize"), MDNode::get(*Ctx, None)); // Recover ctx at the end of a function for (auto FI = F.begin(), FE = F.end(); FI != FE; FI++) { BasicBlock *BB = &*FI; Instruction *Inst = BB->getTerminator(); if (isa(Inst) || isa(Inst)) { IRB.SetInsertPoint(Inst); SCS = IRB.CreateStore(LCS, CallStack); SCS->setMetadata(Mod->getMDKindID("nosanitize"), MDNode::get(*Ctx, None)); } } } void Taint::addFrameTracing(Function &F) { BasicBlock *BB = &F.getEntryBlock(); assert(pred_begin(BB) == pred_end(BB) && "Assume that entry block has no predecessors"); IRBuilder<> IRB(&*(BB->getFirstInsertionPt())); IRB.CreateCall(TaintPushStackFrameFn); // Recover ctx at the end of a function for (auto FI = F.begin(), FE = F.end(); FI != FE; FI++) { BasicBlock *BB = &*FI; Instruction *Inst = BB->getTerminator(); if (isa(Inst) || isa(Inst)) { IRB.SetInsertPoint(Inst); IRB.CreateCall(TaintPopStackFrameFn); } } } bool Taint::initializeModule(Module &M) { Triple TargetTriple(M.getTargetTriple()); const DataLayout &DL = M.getDataLayout(); if (TargetTriple.getOS() != Triple::Linux) report_fatal_error("unsupported operating system"); switch (TargetTriple.getArch()) { case Triple::x86_64: MapParams = &Linux_X86_64_MemoryMapParams; break; default: report_fatal_error("unsupported architecture"); } Mod = &M; Ctx = &M.getContext(); Int8Ty = IntegerType::get(*Ctx, 8); Int16Ty = IntegerType::get(*Ctx, 16); Int32Ty = IntegerType::get(*Ctx, 32); Int64Ty = IntegerType::get(*Ctx, 64); PrimitiveShadowTy = IntegerType::get(*Ctx, ShadowWidthBits); PrimitiveShadowPtrTy = PointerType::getUnqual(PrimitiveShadowTy); IntptrTy = DL.getIntPtrType(*Ctx); VoidPtrTy = PointerType::getUnqual(Int8Ty); ZeroPrimitiveShadow = ConstantInt::getSigned(PrimitiveShadowTy, 0); UninitializedPrimitiveShadow = ConstantInt::getSigned(PrimitiveShadowTy, -1); ShadowPtrMul = ConstantInt::get(IntptrTy, ShadowWidthBytes); ShadowPtrAndMask = ShadowPtrXorMask = ShadowPtrBase = nullptr; if (MapParams->AndMask != 0) ShadowPtrAndMask = ConstantInt::get(IntptrTy, ~MapParams->AndMask); if (MapParams->XorMask != 0) ShadowPtrXorMask = ConstantInt::get(IntptrTy, MapParams->XorMask); if (MapParams->ShadowBase != 0) ShadowPtrBase = ConstantInt::get(IntptrTy, MapParams->ShadowBase); Type *TaintUnionArgs[6] = { PrimitiveShadowTy, PrimitiveShadowTy, Int16Ty, Int16Ty, Int64Ty, Int64Ty}; TaintUnionFnTy = FunctionType::get( PrimitiveShadowTy, TaintUnionArgs, /*isVarArg=*/ false); Type *TaintUnionLoadArgs[3] = { PrimitiveShadowPtrTy, IntptrTy, Int64Ty }; TaintUnionLoadFnTy = FunctionType::get( PrimitiveShadowTy, TaintUnionLoadArgs, /*isVarArg=*/ false); Type *TaintUnionStoreArgs[4] = { PrimitiveShadowTy, PrimitiveShadowPtrTy, IntptrTy, Int64Ty }; TaintUnionStoreFnTy = FunctionType::get( Type::getVoidTy(*Ctx), TaintUnionStoreArgs, /*isVarArg=*/ false); TaintUnimplementedFnTy = FunctionType::get( Type::getVoidTy(*Ctx), Type::getInt8PtrTy(*Ctx), /*isVarArg=*/false); Type *TaintSetLabelArgs[3] = { PrimitiveShadowTy, Type::getInt8PtrTy(*Ctx), IntptrTy }; TaintSetLabelFnTy = FunctionType::get(Type::getVoidTy(*Ctx), TaintSetLabelArgs, /*isVarArg=*/false); TaintNonzeroLabelFnTy = FunctionType::get( Type::getVoidTy(*Ctx), None, /*isVarArg=*/false); TaintVarargWrapperFnTy = FunctionType::get( Type::getVoidTy(*Ctx), Type::getInt8PtrTy(*Ctx), /*isVarArg=*/false); Type *TaintTraceCmpArgs[7] = { PrimitiveShadowTy, PrimitiveShadowTy, Int32Ty, Int32Ty, Int64Ty, Int64Ty, Int32Ty }; TaintTraceCmpFnTy = FunctionType::get( Type::getVoidTy(*Ctx), TaintTraceCmpArgs, false); Type *TaintTraceCondArgs[4] = { PrimitiveShadowTy, IntegerType::get(*Ctx, 1), Int8Ty, Int32Ty }; TaintTraceCondFnTy = FunctionType::get( Type::getVoidTy(*Ctx), TaintTraceCondArgs, false); TaintTraceLoopFnTy = FunctionType::get( Type::getVoidTy(*Ctx), { Int32Ty, Int32Ty }, false); TaintTraceSwitchEndFnTy = FunctionType::get( Type::getVoidTy(*Ctx), { Int32Ty }, false); Type *TaintTraceSelectArgs[] = { PrimitiveShadowTy, PrimitiveShadowTy, PrimitiveShadowTy, Int8Ty, Int8Ty, Int8Ty, Int32Ty }; TaintTraceSelectFnTy = FunctionType::get( PrimitiveShadowTy, TaintTraceSelectArgs, false); TaintTraceIndirectCallFnTy = FunctionType::get( Type::getVoidTy(*Ctx), { PrimitiveShadowTy }, false); Type *TaintTraceGEPArgs[8] = { PrimitiveShadowTy, Int64Ty, PrimitiveShadowTy, Int64Ty, Int64Ty, Int64Ty, Int64Ty, Int32Ty }; TaintTraceGEPFnTy = FunctionType::get( Type::getVoidTy(*Ctx), TaintTraceGEPArgs, false); // __taint_trace_gep_ptr(base_label, offset) -> new_label TaintTraceGEPPtrFnTy = FunctionType::get( Type::getVoidTy(*Ctx), { PrimitiveShadowTy, VoidPtrTy, VoidPtrTy }, false); TaintPushStackFrameFnTy = FunctionType::get( Type::getVoidTy(*Ctx), {}, false); TaintPopStackFrameFnTy = FunctionType::get( Type::getVoidTy(*Ctx), {}, false); Type *TaintTraceAllocaArgs[4] = { PrimitiveShadowTy, Int64Ty, Int64Ty, Int64Ty }; TaintTraceAllocaFnTy = FunctionType::get( PrimitiveShadowTy, TaintTraceAllocaArgs, false); TaintCheckBoundsFnTy = FunctionType::get( Type::getVoidTy(*Ctx), { PrimitiveShadowTy, Int64Ty, PrimitiveShadowTy, Int64Ty }, false); TaintSolveBoundsFnTy = FunctionType::get( Type::getVoidTy(*Ctx), TaintTraceGEPArgs, false); // use the same args as GEP TaintSolveSizeFnTy = FunctionType::get( Type::getVoidTy(*Ctx), { PrimitiveShadowTy, Int64Ty, PrimitiveShadowTy, Int64Ty, Int32Ty }, false); TaintTraceGlobalFnTy = FunctionType::get( PrimitiveShadowTy, { Int64Ty, Int64Ty }, false); TaintDebugFnTy = FunctionType::get(Type::getVoidTy(*Ctx), {PrimitiveShadowTy, PrimitiveShadowTy, PrimitiveShadowTy, PrimitiveShadowTy, PrimitiveShadowTy}, false); ColdCallWeights = MDBuilder(*Ctx).createBranchWeights(1, 1000); return true; } bool Taint::isInstrumented(const Function *F) { return !ABIList.isIn(*F, "uninstrumented"); } bool Taint::isInstrumented(const GlobalAlias *GA) { return !ABIList.isIn(*GA, "uninstrumented"); } bool Taint::isForceZeroLabels(const Function *F) { return ABIList.isIn(*F, "force_zero_labels"); } Taint::WrapperKind Taint::getWrapperKind(Function *F) { // priority custom if (ABIList.isIn(*F, "custom")) return WK_Custom; if (ABIList.isIn(*F, "memcmp")) return WK_Memcmp; if (ABIList.isIn(*F, "strcmp")) return WK_Strcmp; if (ABIList.isIn(*F, "strncmp")) return WK_Strncmp; if (ABIList.isIn(*F, "strchr")) return WK_Strchr; if (ABIList.isIn(*F, "strrchr")) return WK_Strrchr; if (ABIList.isIn(*F, "strstr")) return WK_Strstr; if (ABIList.isIn(*F, "prefixof")) return WK_Prefixof; if (ABIList.isIn(*F, "suffixof")) return WK_Suffixof; if (ABIList.isIn(*F, "strcat")) return WK_Strcat; if (ABIList.isIn(*F, "strsub")) return WK_Strsub; if (ABIList.isIn(*F, "functional")) return WK_Functional; if (ABIList.isIn(*F, "discard")) return WK_Discard; return WK_Warning; } void Taint::addGlobalNameSuffix(GlobalValue *GV) { std::string GVName = std::string(GV->getName()), Suffix = ".taint"; GV->setName(GVName + Suffix); // Try to change the name of the function in module inline asm. We only do // this for specific asm directives, currently only ".symver", to try to avoid // corrupting asm which happens to contain the symbol name as a substring. // Note that the substitution for .symver assumes that the versioned symbol // also has an instrumented name. std::string Asm = GV->getParent()->getModuleInlineAsm(); std::string SearchStr = ".symver " + GVName + ","; size_t Pos = Asm.find(SearchStr); if (Pos != std::string::npos) { Asm.replace(Pos, SearchStr.size(), ".symver " + GVName + Suffix + ","); Pos = Asm.find("@"); if (Pos == std::string::npos) report_fatal_error(Twine("unsupported .symver: ", Asm)); Asm.replace(Pos, 1, Suffix + "@"); GV->getParent()->setModuleInlineAsm(Asm); } } Function * Taint::buildWrapperFunction(Function *F, StringRef NewFName, GlobalValue::LinkageTypes NewFLink, FunctionType *NewFT) { FunctionType *FT = F->getFunctionType(); Function *NewF = Function::Create(NewFT, NewFLink, F->getAddressSpace(), NewFName, F->getParent()); NewF->copyAttributesFrom(F); NewF->removeRetAttrs( AttributeFuncs::typeIncompatible(NewFT->getReturnType())); BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", NewF); if (F->isVarArg() && getWrapperKind(F) != WK_Custom) { // keep the invocation if custom (e.g., open) NewF->removeFnAttr("split-stack"); CallInst::Create(TaintVarargWrapperFn, IRBuilder<>(BB).CreateGlobalStringPtr(F->getName()), "", BB); new UnreachableInst(*Ctx, BB); } else { auto ArgIt = pointer_iterator(NewF->arg_begin()); std::vector Args(ArgIt, ArgIt + FT->getNumParams()); CallInst *CI = CallInst::Create(F, Args, "", BB); if (FT->getReturnType()->isVoidTy()) ReturnInst::Create(*Ctx, BB); else ReturnInst::Create(*Ctx, CI, BB); } return NewF; } Constant *Taint::getOrBuildTrampolineFunction(FunctionType *FT, StringRef FName) { FunctionType *FTT = getTrampolineFunctionType(FT); FunctionCallee C = Mod->getOrInsertFunction(FName, FTT); Function *F = dyn_cast(C.getCallee()); if (F && F->isDeclaration()) { F->setLinkage(GlobalValue::LinkOnceODRLinkage); BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", F); std::vector Args; Function::arg_iterator AI = F->arg_begin() + 1; for (unsigned N = FT->getNumParams(); N != 0; ++AI, --N) Args.push_back(&*AI); CallInst *CI = CallInst::Create(FT, &*F->arg_begin(), Args, "", BB); Type *RetType = FT->getReturnType(); ReturnInst *RI = RetType->isVoidTy() ? ReturnInst::Create(*Ctx, BB) : ReturnInst::Create(*Ctx, CI, BB); // F is called by a wrapped custom function with primitive shadows. So // its arguments and return value need conversion. TaintFunction TF(*this, F, /*IsNativeABI=*/true, /*IsForceZeroLabels=*/false); Function::arg_iterator ValAI = F->arg_begin(), ShadowAI = AI; ++ValAI; for (unsigned N = FT->getNumParams(); N != 0; ++ValAI, ++ShadowAI, --N) { // we don't collapse or expand the shadow TF.ValShadowMap[&*ValAI] = &*ShadowAI; } Function::arg_iterator RetShadowAI = ShadowAI; TaintVisitor(TF).visitCallInst(*CI); if (!RetType->isVoidTy()) { // we don't collapse or expand the shadow new StoreInst(TF.getShadow(RI->getReturnValue()), &*std::prev(F->arg_end()), RI); } } return cast(C.getCallee()); } // Initialize DataFlowSanitizer runtime functions and declare them in the module void Taint::initializeRuntimeFunctions(Module &M) { { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addRetAttribute(M.getContext(), Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 1, Attribute::ZExt); TaintUnionFn = Mod->getOrInsertFunction("__taint_union", TaintUnionFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addRetAttribute(M.getContext(), Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 1, Attribute::ZExt); TaintCheckedUnionFn = Mod->getOrInsertFunction("taint_union", TaintUnionFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addRetAttribute(M.getContext(), Attribute::ZExt); TaintUnionLoadFn = Mod->getOrInsertFunction("__taint_union_load", TaintUnionLoadFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); TaintUnionStoreFn = Mod->getOrInsertFunction("__taint_union_store", TaintUnionStoreFnTy, AL); } { TaintUnimplementedFn = Mod->getOrInsertFunction("__dfsan_unimplemented", TaintUnimplementedFnTy); } { AttributeList AL; AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); TaintSetLabelFn = Mod->getOrInsertFunction("__dfsan_set_label", TaintSetLabelFnTy, AL); } { TaintNonzeroLabelFn = Mod->getOrInsertFunction("__dfsan_nonzero_label", TaintNonzeroLabelFnTy); } { TaintVarargWrapperFn = Mod->getOrInsertFunction("__dfsan_vararg_wrapper", TaintVarargWrapperFnTy); } { TaintDebugFn = Mod->getOrInsertFunction("__taint_debug", TaintDebugFnTy); } TaintRuntimeFunctions.insert( TaintUnionFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintCheckedUnionFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintUnionLoadFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintUnionStoreFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintSetLabelFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintUnimplementedFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintNonzeroLabelFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintVarargWrapperFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintDebugFn.getCallee()->stripPointerCasts()); } // Initializes event callback functions and declare them in the module void Taint::initializeCallbackFunctions(Module &M) { { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addFnAttribute(M.getContext(), Attribute::NoMerge); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 1, Attribute::ZExt); TaintTraceCmpFn = Mod->getOrInsertFunction("__taint_trace_cmp", TaintTraceCmpFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addFnAttribute(M.getContext(), Attribute::NoMerge); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 1, Attribute::ZExt); TaintTraceCondFn = Mod->getOrInsertFunction("__taint_trace_cond", TaintTraceCondFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addFnAttribute(M.getContext(), Attribute::NoMerge); TaintTraceLoopFn = Mod->getOrInsertFunction("__taint_trace_loop", TaintTraceLoopFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addFnAttribute(M.getContext(), Attribute::NoMerge); TaintTraceSwitchEndFn = Mod->getOrInsertFunction("__taint_trace_switch_end", TaintTraceSwitchEndFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addFnAttribute(M.getContext(), Attribute::NoMerge); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 1, Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 2, Attribute::ZExt); TaintTraceSelectFn = Mod->getOrInsertFunction("__taint_trace_select", TaintTraceSelectFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addFnAttribute(M.getContext(), Attribute::NoMerge); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); TaintTraceIndirectCallFn = Mod->getOrInsertFunction("__taint_trace_indcall", TaintTraceIndirectCallFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addFnAttribute(M.getContext(), Attribute::NoMerge); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 2, Attribute::ZExt); TaintTraceGEPFn = Mod->getOrInsertFunction("__taint_trace_gep", TaintTraceGEPFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); TaintTraceGEPPtrFn = Mod->getOrInsertFunction("__taint_trace_gep_ptr", TaintTraceGEPPtrFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); TaintPushStackFrameFn = Mod->getOrInsertFunction("__taint_push_stack_frame", TaintPushStackFrameFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); TaintPopStackFrameFn = Mod->getOrInsertFunction("__taint_pop_stack_frame", TaintPopStackFrameFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addRetAttribute(M.getContext(), Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); TaintTraceAllocaFn = Mod->getOrInsertFunction("__taint_trace_alloca", TaintTraceAllocaFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addRetAttribute(M.getContext(), Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 1, Attribute::ZExt); TaintTraceGlobalFn = Mod->getOrInsertFunction("__taint_trace_global", TaintTraceGlobalFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addFnAttribute(M.getContext(), Attribute::NoMerge); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); TaintCheckBoundsFn = Mod->getOrInsertFunction("__taint_check_bounds", TaintCheckBoundsFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addFnAttribute(M.getContext(), Attribute::NoMerge); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 2, Attribute::ZExt); TaintSolveBoundsFn = Mod->getOrInsertFunction("__taint_solve_bounds", TaintSolveBoundsFnTy, AL); } { AttributeList AL; AL = AL.addFnAttribute(M.getContext(), Attribute::NoUnwind); AL = AL.addFnAttribute(M.getContext(), Attribute::NoMerge); AL = AL.addParamAttribute(M.getContext(), 0, Attribute::ZExt); AL = AL.addParamAttribute(M.getContext(), 2, Attribute::ZExt); TaintSolveSizeFn = Mod->getOrInsertFunction("__taint_solve_size", TaintSolveSizeFnTy, AL); } TaintRuntimeFunctions.insert( TaintTraceCmpFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintTraceCondFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintTraceLoopFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintTraceSwitchEndFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintTraceSelectFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintTraceIndirectCallFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintTraceGEPFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintTraceGEPPtrFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintPushStackFrameFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintPopStackFrameFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintTraceAllocaFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintTraceGlobalFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintCheckBoundsFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintSolveBoundsFn.getCallee()->stripPointerCasts()); TaintRuntimeFunctions.insert( TaintSolveSizeFn.getCallee()->stripPointerCasts()); } bool Taint::runImpl(Module &M) { initializeModule(M); if (ABIList.isIn(M, "skip")) return false; const unsigned InitialGlobalSize = M.global_size(); const unsigned InitialModuleSize = M.size(); bool Changed = false; auto GetOrInsertGlobal = [this, &Changed](StringRef Name, Type *Ty) -> Constant * { Constant *C = Mod->getOrInsertGlobal(Name, Ty); if (GlobalVariable *G = dyn_cast(C)) { Changed |= G->getThreadLocalMode() != GlobalVariable::InitialExecTLSModel; G->setThreadLocalMode(GlobalVariable::InitialExecTLSModel); } return C; }; // These globals must be kept in sync with the ones in dfsan.cpp. ArgTLS = GetOrInsertGlobal("__dfsan_arg_tls", ArrayType::get(Int64Ty, ArgTLSSize / 8)); RetvalTLS = GetOrInsertGlobal("__dfsan_retval_tls", ArrayType::get(Int64Ty, RetvalTLSSize / 8)); CallStack = GetOrInsertGlobal("__taint_trace_callstack", Int32Ty); initializeCallbackFunctions(M); initializeRuntimeFunctions(M); std::vector FnsToInstrument; SmallPtrSet IFuncs; SmallPtrSet FnsWithNativeABI; SmallPtrSet FnsWithForceZeroLabel; SmallPtrSet PersonalityFns; // find ifunc resolvers and their dependencies, we can't instrument them // as dfsan initialization is not done yet for (auto &ifunc : M.ifuncs()) { auto *resolver = ifunc.getResolverFunction(); IFuncs.insert(resolver); for (auto &I : instructions(resolver)) { if (CallBase *CB = dyn_cast(&I)) { if (Function *Callee = CB->getCalledFunction()) { IFuncs.insert(Callee); } } } } for (Function &F : M) { if (!F.isIntrinsic() && !TaintRuntimeFunctions.count(&F) && !IFuncs.count(&F)) { FnsToInstrument.push_back(&F); if (F.hasPersonalityFn()) PersonalityFns.insert(F.getPersonalityFn()); } } if (ClIgnorePersonalityRoutine) { for (auto *C : PersonalityFns) { assert(isa(C) && "Personality routine is not a function!"); Function *F = cast(C); if (!isInstrumented(F)) FnsToInstrument.erase( std::remove(FnsToInstrument.begin(), FnsToInstrument.end(), F), FnsToInstrument.end()); } } // Give function aliases suffixes when necessary, and build wrappers where the // instrumentedness is inconsistent. for (GlobalAlias &GA : llvm::make_early_inc_range(M.aliases())) { // Don't stop on weak. We assume people aren't playing games with the // instrumentedness of overridden weak aliases. auto F = dyn_cast(GA.getAliaseeObject()); if (!F) continue; bool GAInst = isInstrumented(&GA), FInst = isInstrumented(F); if (GAInst && FInst) { addGlobalNameSuffix(&GA); } else if (GAInst != FInst) { // Non-instrumented alias of an instrumented function, or vice versa. // Replace the alias with a native-ABI wrapper of the aliasee. The pass // below will take care of instrumenting it. Function *NewF = buildWrapperFunction(F, "", GA.getLinkage(), F->getFunctionType()); GA.replaceAllUsesWith(ConstantExpr::getBitCast(NewF, GA.getType())); NewF->takeName(&GA); GA.eraseFromParent(); FnsToInstrument.push_back(NewF); } } ReadOnlyNoneAttrs.addAttribute(Attribute::ReadOnly) .addAttribute(Attribute::ReadNone); // First, change the ABI of every function in the module. ABI-listed // functions keep their original ABI and get a wrapper function. for (std::vector::iterator FI = FnsToInstrument.begin(), FE = FnsToInstrument.end(); FI != FE; ++FI) { Function &F = **FI; FunctionType *FT = F.getFunctionType(); bool IsZeroArgsVoidRet = (FT->getNumParams() == 0 && !FT->isVarArg() && FT->getReturnType()->isVoidTy()); if (isInstrumented(&F)) { if (isForceZeroLabels(&F)) FnsWithForceZeroLabel.insert(&F); // Instrumented functions get a '.taint' sufffix. This allows us to more // easily identify cases of mismatching ABIs. This naming scheme is // mangling-compatible (see Itanium ABI), using a vendor-specific suffix. addGlobalNameSuffix(&F); } else if (!IsZeroArgsVoidRet || getWrapperKind(&F) == WK_Custom) { if (FT->isVarArg() && F.isDeclaration() && F.hasAddressTaken() && !isInstrumented(&F)) { // FIXME: vararg functions do used as indirect call targets *FI = nullptr; continue; } // Build a wrapper function for F. The wrapper simply calls F, and is // added to FnsToInstrument so that any instrumentation according to its // WrapperKind is done in the second pass below. // If the function being wrapped has local linkage, then preserve the // function's linkage in the wrapper function. GlobalValue::LinkageTypes wrapperLinkage = F.hasLocalLinkage() ? F.getLinkage() : GlobalValue::LinkOnceODRLinkage; Function *NewF = buildWrapperFunction( &F, std::string("dfsw$") + std::string(F.getName()), wrapperLinkage, FT); NewF->removeFnAttrs(ReadOnlyNoneAttrs); Value *WrappedFnCst = ConstantExpr::getBitCast(NewF, PointerType::getUnqual(FT)); F.replaceAllUsesWith(WrappedFnCst); UnwrappedFnMap[WrappedFnCst] = &F; *FI = NewF; if (!F.isDeclaration()) { // This function is probably defining an interposition of an // uninstrumented function and hence needs to keep the original ABI. // But any functions it may call need to use the instrumented ABI, so // we instrument it in a mode which preserves the original ABI. FnsWithNativeABI.insert(&F); // This code needs to rebuild the iterators, as they may be invalidated // by the push_back, taking care that the new range does not include // any functions added by this code. size_t N = FI - FnsToInstrument.begin(), Count = FE - FnsToInstrument.begin(); FnsToInstrument.push_back(&F); FI = FnsToInstrument.begin() + N; FE = FnsToInstrument.begin() + Count; } // Hopefully, nobody will try to indirectly call a vararg // function... yet. } else if (FT->isVarArg()) { UnwrappedFnMap[&F] = &F; *FI = nullptr; } } for (Function *F : FnsToInstrument) { if (!F || F->isDeclaration()) continue; addContextRecording(*F); if (!F->getName().startswith("dfsw$")) addFrameTracing(*F); removeUnreachableBlocks(*F); TaintFunction TF(*this, F, FnsWithNativeABI.count(F), FnsWithForceZeroLabel.count(F)); // TaintVisitor may create new basic blocks, which confuses df_iterator. // Build a copy of the list before iterating over it. SmallVector BBList(depth_first(&F->getEntryBlock())); for (BasicBlock *BB : BBList) { // check for loop header if (ClTraceLoop) { if (TF.LI->isLoopHeader(BB)) { // This is a loop header Instruction *FI = &*(BB->getFirstInsertionPt()); ConstantInt *CID = ConstantInt::get(Int32Ty, getInstructionId(FI)); ConstantInt *LoopDepth = ConstantInt::get(Int32Ty, TF.LI->getLoopDepth(BB)); IRBuilder<> IRB(FI); IRB.CreateCall(TaintTraceLoopFn, {CID, LoopDepth}); } Loop *L = TF.LI->getLoopFor(BB); if (L) { for (BasicBlock *Succ : successors(BB)) { if (!L->contains(Succ)) { Instruction *FI = &*(Succ->getFirstInsertionPt()); IRBuilder<> IRB(FI); ConstantInt *CID = ConstantInt::get(Int32Ty, getInstructionId(FI)); Loop *SuccL = TF.LI->getLoopFor(Succ); int succ_depth = SuccL ? SuccL->getLoopDepth() : 0; int depth = L->getLoopDepth(); ConstantInt *LoopDepth = ConstantInt::get(Int32Ty, succ_depth - depth); IRB.CreateCall(TaintTraceLoopFn, {CID, LoopDepth}); } } } } Instruction *Inst = &BB->front(); while (true) { // TaintVisitor may split the current basic block, changing the current // instruction's next pointer and moving the next instruction to the // tail block from which we should continue. Instruction *Next = Inst->getNextNode(); // TaintVisitor may delete Inst, so keep track of whether it was a // terminator. bool IsTerminator = Inst->isTerminator(); if (!TF.SkipInsts.count(Inst)) TaintVisitor(TF).visit(Inst); if (IsTerminator) break; Inst = Next; } } // We will not necessarily be able to compute the shadow for every phi node // until we have visited every block. Therefore, the code that handles phi // nodes adds them to the PHIFixups list so that they can be properly // handled here. for (auto &P : TF.PHIFixups) { for (unsigned Val = 0, N = P.Phi->getNumIncomingValues(); Val != N; ++Val) { P.ShadowPhi->setIncomingValue( Val, TF.getShadow(P.Phi->getIncomingValue(Val))); } } } return Changed || !FnsToInstrument.empty() || M.global_size() != InitialGlobalSize || M.size() != InitialModuleSize; } Value *TaintFunction::getArgTLS(Type *T, unsigned ArgOffset, IRBuilder<> &IRB) { Value *Base = IRB.CreatePointerCast(TT.ArgTLS, TT.IntptrTy); if (ArgOffset) Base = IRB.CreateAdd(Base, ConstantInt::get(TT.IntptrTy, ArgOffset)); return IRB.CreateIntToPtr(Base, PointerType::get(TT.getShadowTy(T), 0), "_dfsarg"); } Value *TaintFunction::getRetvalTLS(Type *T, IRBuilder<> &IRB) { return IRB.CreatePointerCast( TT.RetvalTLS, PointerType::get(TT.getShadowTy(T), 0), "_dfsret"); } Value *TaintFunction::getShadowForTLSArgument(Argument *A) { unsigned ArgOffset = 0; const DataLayout &DL = F->getParent()->getDataLayout(); for (auto &FArg : F->args()) { if (!FArg.getType()->isSized()) { if (A == &FArg) break; continue; } unsigned Size = DL.getTypeAllocSize(TT.getShadowTy(&FArg)); if (A != &FArg) { ArgOffset += alignTo(Size, ShadowTLSAlignment); if (ArgOffset > ArgTLSSize) break; // ArgTLS overflows, uses a zero shadow. continue; } if (ArgOffset + Size > ArgTLSSize) break; // ArgTLS overflows, uses a zero shadow. Instruction *ArgTLSPos = &*F->getEntryBlock().begin(); IRBuilder<> IRB(ArgTLSPos); Value *ArgShadowPtr = getArgTLS(FArg.getType(), ArgOffset, IRB); return IRB.CreateAlignedLoad(TT.getShadowTy(&FArg), ArgShadowPtr, ShadowTLSAlignment); } return TT.getZeroShadow(A); } Value *TaintFunction::getShadowForGlobal(GlobalVariable *GV, IRBuilder<> &IRB) { Type *T = GV->getValueType(); if (!T && GV->hasInitializer()) { T = GV->getInitializer()->getType(); } if (T && (T->isArrayTy() || T->isStructTy())) { Module *M = F->getParent(); auto &DL = M->getDataLayout(); uint64_t size = T->isSized() ? DL.getTypeAllocSize(T) : 1; // FIXME: default size? Value *Size = ConstantInt::get(TT.Int64Ty, size); Value *Addr = IRB.CreatePtrToInt(GV, TT.Int64Ty); return IRB.CreateCall(TT.TaintTraceGlobalFn, {Addr, Size}); } return TT.ZeroPrimitiveShadow; // GV is always a ptr } Value *TaintFunction::getShadow(Value *V) { if (!isa(V) && !isa(V)) return TT.getZeroShadow(V); if (IsForceZeroLabels) return TT.getZeroShadow(V); Value *&Shadow = ValShadowMap[V]; if (!Shadow) { if (Argument *A = dyn_cast(V)) { if (IsNativeABI) return TT.getZeroShadow(V); Shadow = getShadowForTLSArgument(A); NonZeroChecks.push_back(Shadow); } else { Shadow = TT.getZeroShadow(V); } } return Shadow; } void TaintFunction::setShadow(Instruction *I, Value *Shadow) { assert(!ValShadowMap.count(I)); ValShadowMap[I] = Shadow; } /// Compute the integer shadow offset that corresponds to a given /// application address. /// /// Offset = (Addr & ~AndMask) ^ XorMask Value *Taint::getShadowOffset(Value *Addr, IRBuilder<> &IRB) { assert(Addr != RetvalTLS && "Reinstrumenting?"); Value *OffsetLong = IRB.CreatePointerCast(Addr, IntptrTy); if (ShadowPtrAndMask) OffsetLong = IRB.CreateAnd(OffsetLong, ShadowPtrAndMask); if (ShadowPtrXorMask) OffsetLong = IRB.CreateXor(OffsetLong, ShadowPtrXorMask); return OffsetLong; } Value *Taint::getShadowAddress(Value *Addr, IRBuilder<> &IRB) { Value *ShadowLong = getShadowOffset(Addr, IRB); if (ShadowPtrBase) ShadowLong = IRB.CreateAdd(ShadowLong, ShadowPtrBase); if (ShadowPtrMul) ShadowLong = IRB.CreateMul(ShadowLong, ShadowPtrMul); return IRB.CreateIntToPtr(ShadowLong, PrimitiveShadowPtrTy); } static inline bool isConstantOne(const Value *V) { if (const ConstantInt *CI = dyn_cast(V)) return CI->isOne(); return false; } Value *TaintFunction::combineBinaryOperatorShadows(BinaryOperator *BO, uint8_t op) { if (BO->getType()->isIntegerTy(1) && BO->getOpcode() == Instruction::Xor && (isConstantOne(BO->getOperand(1)) || isConstantOne(BO->getOperand(0)))) { op = 1; // __dfsan::Not } // else if (BinaryOperator::isNeg(BO)) // op = 2; Value *Shadow1 = getShadow(BO->getOperand(0)); Value *Shadow2 = getShadow(BO->getOperand(1)); Value *Shadow = combineShadows(Shadow1, Shadow2, op, BO); return Shadow; } Value *TaintFunction::combineShadows(Value *V1, Value *V2, uint16_t op, Instruction *Pos) { if (TT.isZeroShadow(V1) && TT.isZeroShadow(V2)) return V1; // filter types Type *Ty = Pos->getOperand(0)->getType(); if (Ty->isFloatingPointTy()) { // check for FP if (!ClTraceFP) return TT.getZeroShadow(Pos); } else if (Ty->isVectorTy()) { // FIXME: vector type return TT.getZeroShadow(Pos); } else if (!Ty->isIntegerTy() && !Ty->isPointerTy()) { // not FP and not vector and not int and not ptr? errs() << "Unknown type: " << *Pos << "\n"; return TT.getZeroShadow(Pos); } // filter size auto &DL = Pos->getModule()->getDataLayout(); uint64_t size = DL.getTypeSizeInBits(Pos->getType()); // FIXME: do not handle type larger than 64-bit if (size > 64) return TT.getZeroShadow(Pos); IRBuilder<> IRB(Pos); if (CmpInst *CI = dyn_cast(Pos)) { // for both icmp and fcmp size = DL.getTypeSizeInBits(CI->getOperand(0)->getType()); // op should be predicate op |= (CI->getPredicate() << 8); } Value *Op = ConstantInt::get(TT.Int16Ty, op); Value *Size = ConstantInt::get(TT.Int16Ty, size); Value *Op1 = Pos->getOperand(0); Ty = Op1->getType(); // bitcast to integer before extending if (Ty->isHalfTy()) Op1 = IRB.CreateBitCast(Op1, TT.Int16Ty); else if (Ty->isFloatTy()) Op1 = IRB.CreateBitCast(Op1, TT.Int32Ty); else if (Ty->isDoubleTy()) Op1 = IRB.CreateBitCast(Op1, TT.Int64Ty); else if (Ty->isPointerTy()) Op1 = IRB.CreatePtrToInt(Op1, TT.Int64Ty); Op1 = IRB.CreateZExtOrTrunc(Op1, TT.Int64Ty); Value *Op2 = ConstantInt::get(TT.Int64Ty, 0); if (Pos->getNumOperands() > 1) { Op2 = Pos->getOperand(1); Ty = Op2->getType(); // bitcast to integer before extending if (Ty->isHalfTy()) Op2 = IRB.CreateBitCast(Op2, TT.Int16Ty); else if (Ty->isFloatTy()) Op2 = IRB.CreateBitCast(Op2, TT.Int32Ty); else if (Ty->isDoubleTy()) Op2 = IRB.CreateBitCast(Op2, TT.Int64Ty); else if (Ty->isPointerTy()) Op2 = IRB.CreatePtrToInt(Op2, TT.Int64Ty); Op2 = IRB.CreateZExtOrTrunc(Op2, TT.Int64Ty); } CallInst *Call = IRB.CreateCall(TT.TaintUnionFn, {V1, V2, Op, Size, Op1, Op2}); Call->addRetAttr(Attribute::ZExt); Call->addParamAttr(0, Attribute::ZExt); Call->addParamAttr(1, Attribute::ZExt); return Call; } Value *TaintFunction::combineCastInstShadows(CastInst *CI, uint8_t op) { Value *Shadow1 = getShadow(CI->getOperand(0)); Value *Shadow2 = TT.getZeroShadow(CI); if (op == Instruction::BitCast) { // BitCast is a no-op, so we can just return the shadow of the operand. return Shadow1; } else if (op == Instruction::AddrSpaceCast) { // AddrSpaceCast is also a no-op for taint, so we can just return the shadow // of the operand. return TT.ZeroPrimitiveShadow; } else { return combineShadows(Shadow1, Shadow2, op, CI); } } Value *TaintFunction::combineCmpInstShadows(CmpInst *CI, uint8_t op) { Value *Shadow1 = getShadow(CI->getOperand(0)); Value *Shadow2 = getShadow(CI->getOperand(1)); Value *Shadow = combineShadows(Shadow1, Shadow2, op, CI); return Shadow; } Align TaintFunction::getShadowAlign(Align InstAlignment) { const Align Alignment = ClPreserveAlignment ? InstAlignment : Align(1); return Align(Alignment.value() * TT.ShadowWidthBytes); } void TaintFunction::checkBounds(Value *Ptr, Value* Size, Instruction *Pos) { IRBuilder<> IRB(Pos); // another place to check for global variable as the ptr Value *PtrShadow = nullptr; if (GlobalVariable *GV = dyn_cast(Ptr->stripPointerCasts())) { PtrShadow = getShadowForGlobal(GV, IRB); } else { PtrShadow = getShadow(Ptr); } Value *SizeShadow = getShadow(Size); // ptr shadow only exists for array and heap object if (!TT.isZeroShadow(PtrShadow)) { Value *Addr = IRB.CreatePtrToInt(Ptr, TT.Int64Ty); Value *Size64 = IRB.CreateZExtOrTrunc(Size, TT.Int64Ty); IRB.CreateCall(TT.TaintCheckBoundsFn, {PtrShadow, Addr, SizeShadow, Size}); } } void TaintFunction::solveBounds(Value *Ptr, Value* Size, Instruction *Pos) { Value *SizeShadow = getShadow(Size); if (TT.isZeroShadow(SizeShadow)) { // If the size is not symbolic, we cannot check if it can go out of bounds. return; } IRBuilder<> IRB(Pos); // another place to check for global variable as the ptr Value *PtrShadow = nullptr; if (GlobalVariable *GV = dyn_cast(Ptr->stripPointerCasts())) { PtrShadow = getShadowForGlobal(GV, IRB); } else { PtrShadow = getShadow(Ptr); } Value *Addr = IRB.CreatePtrToInt(Ptr, TT.Int64Ty); Value *Size64 = IRB.CreateZExtOrTrunc(Size, TT.Int64Ty); ConstantInt *CID = ConstantInt::get(TT.Int32Ty, TT.getInstructionId(Pos)); IRB.CreateCall(TT.TaintSolveSizeFn, {PtrShadow, Addr, SizeShadow, Size64, CID}); } // Generates IR to load shadow corresponding to bytes [Addr, Addr+Size), where // Addr has alignment Align, and take the union of each of those shadows. Value *TaintFunction::loadPrimitiveShadow(Value *Addr, uint64_t Size, uint64_t Align, IRBuilder<> &IRB) { if (Size == 0) return TT.ZeroPrimitiveShadow; Value *ShadowAddr = TT.getShadowAddress(Addr, IRB); CallInst *FallbackCall = IRB.CreateCall( TT.TaintUnionLoadFn, {ShadowAddr, ConstantInt::get(TT.IntptrTy, Size), ConstantInt::get(TT.IntptrTy, Align)}); FallbackCall->addRetAttr(Attribute::ZExt); return FallbackCall; } void TaintFunction::loadShadowRecursive( Value *Shadow, SmallVector &Indices, Type *SubTy, Value *Addr, uint64_t Size, uint64_t Align, IRBuilder<> &IRB) { auto &DL = F->getParent()->getDataLayout(); if (!isa(SubTy) && !isa(SubTy)) { uint64_t SubSize = DL.getTypeStoreSize(SubTy); assert(Size >= SubSize); Align = std::min(Align, (uint64_t)DL.getABITypeAlignment(SubTy)); // load a primitive shadow from address Value *PrimitiveShadow = loadPrimitiveShadow(Addr, SubSize, Align, IRB); // then insert the primitive shadow into the sub-field IRB.CreateInsertValue(Shadow, PrimitiveShadow, Indices); return; } if (ArrayType *AT = dyn_cast(SubTy)) { for (unsigned Idx = 0; Idx < AT->getNumElements(); Idx++) { Indices.push_back(Idx); // double check the remaining size Type *ElemTy = AT->getElementType(); uint64_t ElemSize = DL.getTypeStoreSize(ElemTy); uint64_t Offset = ElemSize * Idx; assert(Offset <= Size); // get the address of the array element Value *SubAddr = IRB.CreateConstGEP2_32(AT, Addr, 0, Idx); loadShadowRecursive(Shadow, Indices, ElemTy, SubAddr, Size - Offset, Align, IRB); Indices.pop_back(); } return; } if (StructType *ST = dyn_cast(SubTy)) { const StructLayout *SL = DL.getStructLayout(ST); for (unsigned Idx = 0; Idx < ST->getNumElements(); Idx++) { Indices.push_back(Idx); // double check the remaining size uint64_t Offset = SL->getElementOffset(Idx); assert(Offset <= Size); Type *ElemTy = ST->getElementType(Idx); // get the address of the struct field Value *SubAddr = IRB.CreateConstGEP2_32(ST, Addr, 0, Idx); loadShadowRecursive(Shadow, Indices, ElemTy, SubAddr, Size - Offset, Align, IRB); Indices.pop_back(); } return; } llvm_unreachable("Unexpected shadow type"); } Value *TaintFunction::loadShadow(Type *T, Value *Addr, uint64_t Size, Align Alignment, Instruction *Pos) { IRBuilder<> IRB(Pos); // if loading from a local variable, load label from its shadow if (AllocaInst *AI = dyn_cast(Addr)) { const auto i = AllocaShadowMap.find(AI); if (i != AllocaShadowMap.end()) { return IRB.CreateLoad(TT.getShadowTy(T), i->second); } } // check if the target object is a constant SmallVector Objs; getUnderlyingObjects(Addr, Objs); bool AllConstants = true; for (const Value *Obj : Objs) { if (isa(Obj) || isa(Obj)) continue; if (isa(Obj) && cast(Obj)->isConstant()) continue; AllConstants = false; break; } if (AllConstants) return TT.getZeroShadow(T); if (Size == 0) return TT.ZeroPrimitiveShadow; const uint64_t ShadowAlign = getShadowAlign(Alignment).value(); // now check if we're loading an aggragate object if (!isa(T) && !isa(T)) return loadPrimitiveShadow(Addr, Size, ShadowAlign, IRB); // if loading an aggregate object, load its shadow recursively SmallVector Indices; Type *ShadowTy = TT.getShadowTy(T); Value *Shadow = UndefValue::get(ShadowTy); loadShadowRecursive(Shadow, Indices, T, Addr, Size, ShadowAlign, IRB); return Shadow; } static AtomicOrdering addAcquireOrdering(AtomicOrdering AO) { switch (AO) { case AtomicOrdering::NotAtomic: return AtomicOrdering::NotAtomic; case AtomicOrdering::Unordered: case AtomicOrdering::Monotonic: case AtomicOrdering::Acquire: return AtomicOrdering::Acquire; case AtomicOrdering::Release: case AtomicOrdering::AcquireRelease: return AtomicOrdering::AcquireRelease; case AtomicOrdering::SequentiallyConsistent: return AtomicOrdering::SequentiallyConsistent; } llvm_unreachable("Unknown ordering"); } static AtomicOrdering addReleaseOrdering(AtomicOrdering AO) { switch (AO) { case AtomicOrdering::NotAtomic: return AtomicOrdering::NotAtomic; case AtomicOrdering::Unordered: case AtomicOrdering::Monotonic: case AtomicOrdering::Release: return AtomicOrdering::Release; case AtomicOrdering::Acquire: case AtomicOrdering::AcquireRelease: return AtomicOrdering::AcquireRelease; case AtomicOrdering::SequentiallyConsistent: return AtomicOrdering::SequentiallyConsistent; } llvm_unreachable("Unknown ordering"); } void TaintVisitor::visitAtomicRMWInst(AtomicRMWInst &I) { auto &DL = I.getModule()->getDataLayout(); Value *Ptr = I.getPointerOperand(); Value *Val = I.getValOperand(); Type *Ty = I.getType(); uint64_t Size = DL.getTypeStoreSize(Ty); Value *Shadow1 = TF.loadShadow(Ty, Ptr, Size, I.getAlign(), &I); Value *Shadow2 = TF.getShadow(Val); Value *Shadow = nullptr; Value *Op1 = nullptr, *Cond = nullptr; IRBuilder<> IRB(&I); switch (I.getOperation()) { case AtomicRMWInst::Xchg: Shadow = Shadow2; break; case AtomicRMWInst::Add: Shadow = TF.combineShadows(Shadow1, Shadow2, BinaryOperator::Add, &I); break; case AtomicRMWInst::Sub: Shadow = TF.combineShadows(Shadow1, Shadow2, BinaryOperator::Sub, &I); break; case AtomicRMWInst::And: Shadow = TF.combineShadows(Shadow1, Shadow2, BinaryOperator::And, &I); break; case AtomicRMWInst::Nand: Shadow = TF.combineShadows(Shadow1, Shadow2, BinaryOperator::And, &I); Shadow = TF.combineShadows(TF.TT.getZeroShadow(Ty), Shadow, 2, &I); // __dfsan::Neg break; case AtomicRMWInst::Or: Shadow = TF.combineShadows(Shadow1, Shadow2, BinaryOperator::Or, &I); break; case AtomicRMWInst::Xor: Shadow = TF.combineShadows(Shadow1, Shadow2, BinaryOperator::Xor, &I); break; case AtomicRMWInst::Max: Op1 = IRB.CreateLoad(Ty, Ptr, true); Cond = IRB.CreateICmpSGT(Op1, Val); Shadow = IRB.CreateSelect(Cond, Shadow1, Shadow2); break; case AtomicRMWInst::Min: Op1 = IRB.CreateLoad(Ty, Ptr, true); Cond = IRB.CreateICmpSLT(Op1, Val); Shadow = IRB.CreateSelect(Cond, Shadow1, Shadow2); break; case AtomicRMWInst::UMax: Op1 = IRB.CreateLoad(Ty, Ptr, true); Cond = IRB.CreateICmpUGT(Op1, Val); Shadow = IRB.CreateSelect(Cond, Shadow1, Shadow2); break; case AtomicRMWInst::UMin: Op1 = IRB.CreateLoad(Ty, Ptr, true); Cond = IRB.CreateICmpULT(Op1, Val); Shadow = IRB.CreateSelect(Cond, Shadow1, Shadow2); break; // TODO: support extra operations default: assert(false && "unimplemented atomicrmw operation"); break; } TF.storeShadow(Ptr, Ty, Size, I.getAlign(), Shadow, &I); TF.setShadow(&I, Shadow1); // TODO: The ordering change follows MSan. It is possible not to change // ordering because we always set and use 0 shadows. I.setOrdering(addReleaseOrdering(I.getOrdering())); } void TaintVisitor::visitLoadInst(LoadInst &LI) { if (LI.getMetadata("nosanitize")) return; auto &DL = LI.getModule()->getDataLayout(); uint64_t Size = DL.getTypeStoreSize(LI.getType()); if (Size == 0) { TF.setShadow(&LI, TF.TT.getZeroShadow(&LI)); return; } // When an application load is atomic, increase atomic ordering between // atomic application loads and stores to ensure happen-before order; load // shadow data after application data; store zero shadow data before // application data. This ensure shadow loads return either labels of the // initial application data or zeros. if (LI.isAtomic()) LI.setOrdering(addAcquireOrdering(LI.getOrdering())); Instruction *Pos = LI.isAtomic() ? LI.getNextNode() : &LI; // check bounds first if (ClTraceBound) TF.checkBounds(LI.getPointerOperand(), ConstantInt::get(TF.TT.Int64Ty, Size), Pos); Value *Shadow = TF.loadShadow(LI.getType(), LI.getPointerOperand(), Size, LI.getAlign(), Pos); #if 0 //FIXME: tainted pointer if (ClCombinePointerLabelsOnLoad) { Value *PtrShadow = TF.getShadow(LI.getPointerOperand()); Shadow = TF.combineShadows(Shadow, PtrShadow, Pos); } #endif if (!TF.TT.isZeroShadow(Shadow)) TF.NonZeroChecks.push_back(Shadow); TF.setShadow(&LI, Shadow); } void TaintFunction::storeShadowRecursive( Value *Shadow, SmallVector &Indices, Type *SubShadowTy, Value *Addr, uint64_t Size, uint64_t Align, IRBuilder<> &IRB) { auto &DL = F->getParent()->getDataLayout(); if (!isa(SubShadowTy) && !isa(SubShadowTy)) { uint64_t SubSize = DL.getTypeStoreSize(SubShadowTy); assert(Size >= SubSize); Align = std::min(Align, (uint64_t)DL.getABITypeAlignment(SubShadowTy)); // load a primitive shadow from the sub-field Value *PrimitiveShadow = IRB.CreateExtractValue(Shadow, Indices); // then store the primitive shadow into the shadow address Value *ShadowAddr = TT.getShadowAddress(Addr, IRB); IRB.CreateCall(TT.TaintUnionStoreFn, {PrimitiveShadow, ShadowAddr, ConstantInt::get(TT.IntptrTy, SubSize), ConstantInt::get(TT.IntptrTy, Align)}); return; } if (ArrayType *AT = dyn_cast(SubShadowTy)) { for (unsigned Idx = 0; Idx < AT->getNumElements(); Idx++) { Indices.push_back(Idx); // double check the remaining size Type *ElemTy = AT->getElementType(); uint64_t ElemSize = DL.getTypeStoreSize(ElemTy); uint64_t Offset = ElemSize * Idx; assert(Offset <= Size); // get the address of the array element Value *SubAddr = IRB.CreateConstGEP2_32(AT, Addr, 0, Idx); storeShadowRecursive(Shadow, Indices, ElemTy, SubAddr, Size - Offset, Align, IRB); Indices.pop_back(); } return; } if (StructType *ST = dyn_cast(SubShadowTy)) { const StructLayout *SL = DL.getStructLayout(ST); for (unsigned Idx = 0; Idx < ST->getNumElements(); Idx++) { Indices.push_back(Idx); // double check the remaining size uint64_t Offset = SL->getElementOffset(Idx); assert(Offset <= Size); Type *ElemTy = ST->getElementType(Idx); // get the address of the struct field Value *SubAddr = IRB.CreateConstGEP2_32(ST, Addr, 0, Idx); storeShadowRecursive(Shadow, Indices, ElemTy, SubAddr, Size - Offset, Align, IRB); Indices.pop_back(); } return; } llvm_unreachable("Unexpected shadow type"); } void TaintFunction::storeShadow(Value *Addr, Type *T, uint64_t Size, Align Alignment, Value *Shadow, Instruction *Pos) { IRBuilder<> IRB(Pos); if (AllocaInst *AI = dyn_cast(Addr)) { const auto i = AllocaShadowMap.find(AI); if (i != AllocaShadowMap.end()) { auto *SI = IRB.CreateStore(Shadow, i->second); SkipInsts.insert(SI); return; } } Value *ShadowAddr = TT.getShadowAddress(Addr, IRB); const Align ShadowAlign = getShadowAlign(Alignment); // check if the shadow is zero, if so, clear the shadow memory regardless // of the shadow type if (TT.isZeroShadow(Shadow)) { IntegerType *ShadowTy = IntegerType::get(*TT.Ctx, Size * TT.ShadowWidthBits); Value *ExtZeroShadow = ConstantInt::get(ShadowTy, 0); Value *ExtShadowAddr = IRB.CreateBitCast(ShadowAddr, PointerType::getUnqual(ShadowTy)); IRB.CreateAlignedStore(ExtZeroShadow, ExtShadowAddr, ShadowAlign); return; } // now check if we're storing an aggragate shadow object if (!isa(T) && !isa(T)) { IRB.CreateCall(TT.TaintUnionStoreFn, {Shadow, ShadowAddr, ConstantInt::get(TT.IntptrTy, Size), ConstantInt::get(TT.IntptrTy, ShadowAlign.value())}); return; } // if storing an aggregate shadow object, store its shadow recursively // we want to do this so union_store may have a chance to simplify some // constraints SmallVector Indices; storeShadowRecursive(Shadow, Indices, T, Addr, Size, ShadowAlign.value(), IRB); } void TaintVisitor::visitStoreInst(StoreInst &SI) { if (SI.getMetadata("nosanitize")) return; auto &DL = SI.getModule()->getDataLayout(); Value *Val = SI.getValueOperand(); Type* VT = SI.getValueOperand()->getType(); uint64_t Size = DL.getTypeStoreSize(VT); if (Size == 0) return; // When an application store is atomic, increase atomic ordering between // atomic application loads and stores to ensure happen-before order; load // shadow data after application data; store zero shadow data before // application data. This ensure shadow loads return either labels of the // initial application data or zeros. if (SI.isAtomic()) SI.setOrdering(addReleaseOrdering(SI.getOrdering())); Value* Shadow = SI.isAtomic() ? TF.TT.getZeroShadow(VT) : TF.getShadow(Val); // check bounds first if (ClTraceBound) TF.checkBounds(SI.getPointerOperand(), ConstantInt::get(TF.TT.Int64Ty, Size), &SI); #if 0 //FIXME: tainted pointer if (ClCombinePointerLabelsOnStore) { Value *PtrShadow = TF.getShadow(SI.getPointerOperand()); Shadow = TF.combineShadows(Shadow, PtrShadow, &SI); } #endif TF.storeShadow(SI.getPointerOperand(), VT, Size, SI.getAlign(), Shadow, &SI); } //void TaintVisitor::visitUnaryOperator(UnaryOperator &UO) { //} void TaintVisitor::visitBinaryOperator(BinaryOperator &BO) { if (BO.getMetadata("nosanitize")) return; if (BO.getType()->isFloatingPointTy()) return; Value *CombinedShadow = TF.combineBinaryOperatorShadows(&BO, BO.getOpcode()); TF.setShadow(&BO, CombinedShadow); } void TaintVisitor::visitCastInst(CastInst &CI) { if (CI.getMetadata("nosanitize")) return; // Special case: if this is the bitcast (there is exactly 1 allowed) between // a musttail call and a ret, don't instrument. New instructions are not // allowed after a musttail call. if (auto *C = dyn_cast(CI.getOperand(0))) if (C->isMustTailCall()) return; Value *CombinedShadow = TF.combineCastInstShadows(&CI, CI.getOpcode()); TF.setShadow(&CI, CombinedShadow); } void TaintFunction::visitCmpInst(CmpInst *I) { // get operand Value *Op1 = I->getOperand(0); Value *Op2 = I->getOperand(1); Value *Op1Shadow = getShadow(Op1); Value *Op2Shadow = getShadow(Op2); if (TT.isZeroShadow(Op1Shadow) && TT.isZeroShadow(Op2Shadow)) return; Module *M = F->getParent(); auto &DL = M->getDataLayout(); unsigned size = DL.getTypeSizeInBits(Op1->getType()); IRBuilder<> IRB(I); Op1 = IRB.CreateZExtOrTrunc(Op1, TT.Int64Ty); Op2 = IRB.CreateZExtOrTrunc(Op2, TT.Int64Ty); ConstantInt *Size = ConstantInt::get(TT.Int32Ty, size); ConstantInt *Predicate = ConstantInt::get(TT.Int32Ty, I->getPredicate()); ConstantInt *CID = ConstantInt::get(TT.Int32Ty, TT.getInstructionId(I)); IRB.CreateCall(TT.TaintTraceCmpFn, {Op1Shadow, Op2Shadow, Size, Predicate, Op1, Op2, CID}); } void TaintVisitor::visitCmpInst(CmpInst &CI) { if (CI.getMetadata("nosanitize")) return; // FIXME: integer only now if (!ClTraceFP && !isa(CI)) return; #if 0 //TODO make an option TF.visitCmpInst(&CI); #endif Value *CombinedShadow = TF.combineCmpInstShadows(&CI, CI.getOpcode()); TF.setShadow(&CI, CombinedShadow); } void TaintFunction::visitSwitchInst(SwitchInst *I) { Module *M = F->getParent(); auto &DL = M->getDataLayout(); // get operand Value *Cond = I->getCondition(); Value *CondShadow = getShadow(Cond); if (TT.isZeroShadow(CondShadow)) return; uint32_t cid = TT.getInstructionId(I); if (cid == TT.InvalidInstructionId) return; unsigned size = DL.getTypeSizeInBits(Cond->getType()); ConstantInt *Size = ConstantInt::get(TT.Int32Ty, size); ConstantInt *Predicate = ConstantInt::get(TT.Int32Ty, 32); // EQ, == ConstantInt *CID = ConstantInt::get(TT.Int32Ty, cid); IRBuilder<> IRB(I); for (auto C : I->cases()) { Value *CV = C.getCaseValue(); Cond = IRB.CreateZExtOrTrunc(Cond, TT.Int64Ty); CV = IRB.CreateZExtOrTrunc(CV, TT.Int64Ty); IRB.CreateCall(TT.TaintTraceCmpFn, {CondShadow, TT.ZeroPrimitiveShadow, Size, Predicate, Cond, CV, CID}); } IRB.CreateCall(TT.TaintTraceSwitchEndFn, {CID}); } void TaintVisitor::visitSwitchInst(SwitchInst &SWI) { if (SWI.getMetadata("nosanitize")) return; TF.visitSwitchInst(&SWI); } void TaintVisitor::visitLandingPadInst(LandingPadInst &LPI) { // We do not need to track data through LandingPadInst. // // For the C++ exceptions, if a value is thrown, this value will be stored // in a memory location provided by __cxa_allocate_exception(...) (on the // throw side) or __cxa_begin_catch(...) (on the catch side). // This memory will have a shadow, so with the loads and stores we will be // able to propagate labels on data thrown through exceptions, without any // special handling of the LandingPadInst. // // The second element in the pair result of the LandingPadInst is a // register value, but it is for a type ID and should never be tainted. TF.setShadow(&LPI, TF.TT.getZeroShadow(&LPI)); } void TaintFunction::visitGEPInst(GetElementPtrInst *I) { Module *M = F->getParent(); auto &DL = M->getDataLayout(); int64_t CurrentOffset = 0; IRBuilder<> IRB(I); Value *Base = I->getPointerOperand(); Value *Bounds = TT.getZeroShadow(Base); if (ClTraceBound) { // get bounds info for base pointer if (auto *GV = dyn_cast(Base->stripPointerCasts())) { // if the base pointer is a global variable // we can't get its shadow from the shadow map Bounds = getShadowForGlobal(GV, IRB); } else { Bounds = getShadow(Base); if (TT.isZeroShadow(Bounds)) { // try striping the pointer cast Bounds = getShadow(Base->stripPointerCasts()); } } } Type *POTy = I->getPointerOperandType(); Type *ETy = POTy; for (auto &Idx: I->indices()) { // reference: DataLayout::getIndexedOffsetInType Value *Index = &*Idx; if (StructType *STy = dyn_cast(ETy)) { // index into struct has to be constant assert(isa(Index) && "inllegal struct index"); unsigned FieldNo = cast(Index)->getZExtValue(); const StructLayout *SL = DL.getStructLayout(STy); CurrentOffset += SL->getElementOffset(FieldNo); ETy = STy->getTypeAtIndex(FieldNo); } else { uint64_t NumElements = 0; int64_t ElemSize = 0; if (PointerType *PTy = dyn_cast(ETy)) { assert(PTy == POTy && "inllegal pointer index"); ETy = I->getSourceElementType(); NumElements = 0; // we don't know the number of elements ElemSize = DL.getTypeAllocSize(ETy); } else if (ArrayType *ATy = dyn_cast(ETy)) { ETy = ATy->getElementType(); NumElements = ATy->getNumElements(); ElemSize = DL.getTypeAllocSize(ETy); } else { VectorType *VTy = dyn_cast(ETy); assert(VTy && "inllegal index type"); ETy = VTy->getElementType(); NumElements = VTy->getElementCount().getFixedValue(); ElemSize = DL.getTypeStoreSize(ETy); break; } if (isa(Index)) { int64_t arrayIdx = cast(Index)->getSExtValue(); CurrentOffset += arrayIdx * ElemSize; } else if (Index->getType()->isIntegerTy()) { // FIXEME: handle vector type // non-constant index, check if it's tainted Value *Shadow = getShadow(Index); if (!TT.isZeroShadow(Shadow)) { Index = IRB.CreateZExtOrTrunc(Index, TT.Int64Ty); ConstantInt *Offset = ConstantInt::get(TT.Int64Ty, CurrentOffset); ConstantInt *NE = ConstantInt::get(TT.Int64Ty, NumElements); ConstantInt *ES = ConstantInt::get(TT.Int64Ty, ElemSize); Value *Ptr = IRB.CreatePtrToInt(I->getPointerOperand(), TT.Int64Ty); ConstantInt *CID = ConstantInt::get(TT.Int32Ty, TT.getInstructionId(I)); if (ClSolveUB) { // check if index can go out of bounds // -fsanitize=local-bounds // must be added before tracing GEP, otherwise index_label == index // will be added as nested constraint IRB.CreateCall(TT.TaintSolveBoundsFn, {Bounds, Ptr, Shadow, Index, NE, ES, Offset, CID}); } if (ClTraceGEPOffset) { IRB.CreateCall(TT.TaintTraceGEPFn, {Bounds, Ptr, Shadow, Index, NE, ES, Offset, CID}); } } else { break; } } } } if (ClTraceBound) { // propagate bounds info setShadow(I, Bounds); } // For constant offset GEPs on string op pointers, create fstr_off label // to track the offset (e.g., sep + 1 where sep is from strchr) if (CurrentOffset != 0 && !TT.isZeroShadow(Bounds)) { IRBuilder<> IRB(I->getNextNode()); Bounds = IRB.CreateCall(TT.TaintTraceGEPPtrFn, {Bounds, I, Base}); } } void TaintVisitor::visitGetElementPtrInst(GetElementPtrInst &GEPI) { if (!ClTraceGEPOffset && !ClTraceBound) return; if (GEPI.getMetadata("nosanitize")) return; TF.visitGEPInst(&GEPI); } void TaintVisitor::visitExtractElementInst(ExtractElementInst &I) { //FIXME: } void TaintVisitor::visitInsertElementInst(InsertElementInst &I) { //FIXME: } void TaintVisitor::visitShuffleVectorInst(ShuffleVectorInst &I) { //FIXME: } void TaintVisitor::visitExtractValueInst(ExtractValueInst &I) { if (I.getMetadata("nosanitize")) return; IRBuilder<> IRB(&I); Value *Agg = I.getAggregateOperand(); Value *AggShadow = TF.getShadow(Agg); Value *ResShadow = IRB.CreateExtractValue(AggShadow, I.getIndices()); TF.setShadow(&I, ResShadow); } void TaintVisitor::visitInsertValueInst(InsertValueInst &I) { if (I.getMetadata("nosanitize")) return; IRBuilder<> IRB(&I); Value *AggShadow = TF.getShadow(I.getAggregateOperand()); Value *InsShadow = TF.getShadow(I.getInsertedValueOperand()); Value *Res = IRB.CreateInsertValue(AggShadow, InsShadow, I.getIndices()); TF.setShadow(&I, Res); } Value *TaintFunction::visitAllocaInst(AllocaInst *I, Value *ArraySize, Type *ElTy) { // insert after the instruction to get the address BasicBlock::iterator ip(I); IRBuilder<> IRB(I->getParent(), ++ip); // prepare array size Value *Size = IRB.CreateZExtOrTrunc(ArraySize, TT.Int64Ty); Value *SizeShadow = getShadow(ArraySize); // get element size Module *M = F->getParent(); auto &DL = M->getDataLayout(); uint64_t es = DL.getTypeAllocSize(ElTy); ConstantInt *ElemSize = ConstantInt::get(TT.Int64Ty, es); // get address Value *Address = IRB.CreatePtrToInt(I, TT.Int64Ty); return IRB.CreateCall(TT.TaintTraceAllocaFn, {SizeShadow, Size, ElemSize, Address}); } void TaintVisitor::visitAllocaInst(AllocaInst &I) { bool AllLoadsStores = true; for (User *U : I.users()) { if (isa(U)) { continue; } if (StoreInst *SI = dyn_cast(U)) { if (SI->getPointerOperand() == &I) { continue; } } AllLoadsStores = false; break; } if (AllLoadsStores) { IRBuilder<> IRB(&I); AllocaInst *AI = IRB.CreateAlloca(TF.TT.getShadowTy(I.getAllocatedType()), I.getArraySize(), I.getName() + ".taint"); TF.AllocaShadowMap[&I] = AI; if (ClTraceBound) { // set shadow to uninit IRB.CreateStore(TF.TT.getUninitializedShadow(I.getAllocatedType()), AI); } } if (!ClTraceBound) { TF.setShadow(&I, TF.TT.ZeroPrimitiveShadow); } else { Type *T = I.getAllocatedType(); Value *ArraySize = I.getArraySize(); bool TrackBounds = I.isArrayAllocation() | T->isArrayTy() | T->isStructTy(); if (TrackBounds) { // array could be VLA, rely on runtime Value *Bounds = TF.visitAllocaInst(&I, ArraySize, T); TF.setShadow(&I, Bounds); } else { TF.setShadow(&I, TF.TT.ZeroPrimitiveShadow); // no bounds } // set uninit shadow for allocation with constant size if (!AllLoadsStores && isa(ArraySize)) { Value *Init = TF.TT.UninitializedPrimitiveShadow; // XXX: skip __va_list_tag, as we don't trace llvm.va_start if (ArrayType *AT = dyn_cast(T)) { T = AT->getElementType(); } if (T->isStructTy() && T->getStructName().find("__va_list_tag") != StringRef::npos) { // FIXME: don't set uninit, assuming llvm.va_start will be called Init = TF.TT.ZeroPrimitiveShadow; } // handle not all loads and stores cases here IRBuilder<> IRB(I.getNextNode()); auto DL = I.getModule()->getDataLayout(); auto size = I.getAllocationSizeInBits(DL); assert(size != None); Value *Size = ConstantInt::get(TF.TT.IntptrTy, (size->getFixedValue() + 7) >> 3); IRB.CreateCall(TF.TT.TaintSetLabelFn, {Init, IRB.CreateBitCast(&I, Type::getInt8PtrTy(*TF.TT.Ctx)), Size}); } } } Value* TaintFunction::visitSelectInst(Value *Cond, Value *TrueShadow, Value *FalseShadow, SelectInst *I) { Value *CondShadow = getShadow(Cond); Type *T = I->getType(); if (!T->isIntegerTy(1)) { // most cases visitCondition(Cond, I); return TrueShadow == FalseShadow ? TrueShadow : SelectInst::Create(Cond, TrueShadow, FalseShadow, "", I); } // special case, when select is used to implement logical AND and OR IRBuilder<> IRB(I); Cond = IRB.CreateZExt(Cond, TT.Int8Ty); Value *TrueVal = IRB.CreateZExt(I->getTrueValue(), TT.Int8Ty); Value *FalseVal = IRB.CreateZExt(I->getFalseValue(), TT.Int8Ty); ConstantInt *CID = ConstantInt::get(TT.Int32Ty, TT.getInstructionId(I)); return IRB.CreateCall(TT.TaintTraceSelectFn, {CondShadow, TrueShadow, FalseShadow, Cond, TrueVal, FalseVal, CID}); } void TaintVisitor::visitSelectInst(SelectInst &I) { Value *Condition = I.getCondition(); Value *TrueShadow = TF.getShadow(I.getTrueValue()); Value *FalseShadow = TF.getShadow(I.getFalseValue()); if (isa(Condition->getType())) { //FIXME: errs() << "WARNING: vector condition in Select" << I << "\n"; TF.setShadow(&I, TF.TT.ZeroPrimitiveShadow); } else { Value *ShadowSel = TF.visitSelectInst(Condition, TrueShadow, FalseShadow, &I); TF.setShadow(&I, ShadowSel); } } void TaintVisitor::visitMemSetInst(MemSetInst &I) { // check bounds before memset if (ClTraceBound) { TF.checkBounds(I.getDest(), I.getLength(), &I); } if (ClSolveUB) { TF.solveBounds(I.getDest(), I.getLength(), &I); } IRBuilder<> IRB(&I); Value *ValShadow = TF.getShadow(I.getValue()); IRB.CreateCall( TF.TT.TaintSetLabelFn, {ValShadow, IRB.CreateBitCast(I.getDest(), Type::getInt8PtrTy(*TF.TT.Ctx)), IRB.CreateZExtOrTrunc(I.getLength(), TF.TT.IntptrTy)}); } void TaintVisitor::visitMemTransferInst(MemTransferInst &I) { // check bounds before memcpy if (ClTraceBound) { TF.checkBounds(I.getDest(), I.getLength(), &I); TF.checkBounds(I.getSource(), I.getLength(), &I); } if (ClSolveUB) { TF.solveBounds(I.getDest(), I.getLength(), &I); TF.solveBounds(I.getSource(), I.getLength(), &I); } IRBuilder<> IRB(&I); Value *DestShadow = TF.TT.getShadowAddress(I.getDest(), IRB); Value *SrcShadow = TF.TT.getShadowAddress(I.getSource(), IRB); Value *LenShadow = IRB.CreateMul( I.getLength(), ConstantInt::get(I.getLength()->getType(), TF.TT.ShadowWidthBytes)); Type *Int8Ptr = Type::getInt8PtrTy(*TF.TT.Ctx); DestShadow = IRB.CreateBitCast(DestShadow, Int8Ptr); SrcShadow = IRB.CreateBitCast(SrcShadow, Int8Ptr); auto *MTI = cast( IRB.CreateCall(I.getFunctionType(), I.getCalledOperand(), {DestShadow, SrcShadow, LenShadow, I.getVolatileCst()})); if (ClPreserveAlignment) { MTI->setDestAlignment(I.getDestAlign() * TF.TT.ShadowWidthBytes); MTI->setSourceAlignment(I.getSourceAlign() * TF.TT.ShadowWidthBytes); } else { MTI->setDestAlignment(Align(TF.TT.ShadowWidthBytes)); MTI->setSourceAlignment(Align(TF.TT.ShadowWidthBytes)); } } static bool isAMustTailRetVal(Value *RetVal) { // Tail call may have a bitcast between return. if (auto *I = dyn_cast(RetVal)) { RetVal = I->getOperand(0); } if (auto *I = dyn_cast(RetVal)) { return I->isMustTailCall(); } return false; } void TaintVisitor::visitReturnInst(ReturnInst &RI) { Value *RV = RI.getReturnValue(); if (!TF.IsNativeABI && RV) { // Don't emit the instrumentation for musttail call returns. if (isAMustTailRetVal(RV)) return; Value *S = TF.getShadow(RV); IRBuilder<> IRB(&RI); Type *RT = TF.F->getFunctionType()->getReturnType(); unsigned Size = getDataLayout().getTypeAllocSize(TF.TT.getShadowTy(RT)); if (Size <= RetvalTLSSize) { // If the size overflows, stores nothing. At callsite, oversized return // shadows are set to zero. IRB.CreateAlignedStore(S, TF.getRetvalTLS(RT, IRB), ShadowTLSAlignment); } } } void TaintVisitor::addShadowArguments(Function *F, CallBase &CB, std::vector &Args, IRBuilder<> &IRB) { FunctionType *FT = F->getFunctionType(); auto *I = CB.arg_begin(); // Adds non-variable argument shadows. for (unsigned N = FT->getNumParams(); N != 0; ++I, --N) { // Finds potential shadow for GV auto *GV = dyn_cast((*I)->stripPointerCasts()); Value *Shadow = GV ? TF.getShadowForGlobal(GV, IRB) : TF.getShadow(*I); Args.push_back(Shadow); // we don't collapse shadow } // Adds variable argument shadows. if (FT->isVarArg()) { auto *LabelVATy = ArrayType::get(TF.TT.PrimitiveShadowTy, CB.arg_size() - FT->getNumParams()); auto *LabelVAAlloca = new AllocaInst(LabelVATy, getDataLayout().getAllocaAddrSpace(), "labelva", &TF.F->getEntryBlock().front()); for (unsigned N = 0; I != CB.arg_end(); ++I, ++N) { auto LabelVAPtr = IRB.CreateStructGEP(LabelVATy, LabelVAAlloca, N); auto *GV = dyn_cast((*I)->stripPointerCasts()); Value *Shadow = GV ? TF.getShadowForGlobal(GV, IRB) : TF.getShadow(*I); IRB.CreateStore(Shadow, LabelVAPtr); } Args.push_back(IRB.CreateStructGEP(LabelVATy, LabelVAAlloca, 0)); } // Adds the return value shadow. Type *RetTy = FT->getReturnType(); if (!RetTy->isVoidTy()) { if (!TF.LabelReturnAlloca) { TF.LabelReturnAlloca = new AllocaInst(TF.TT.getShadowTy(RetTy), // we dont collapse shadow getDataLayout().getAllocaAddrSpace(), "labelreturn", &TF.F->getEntryBlock().front()); } Args.push_back(TF.LabelReturnAlloca); } } bool TaintVisitor::visitWrappedCallBase(Function *F, CallBase &CB) { IRBuilder<> IRB(&CB); Value *Shadow = nullptr; FunctionType *FT = F->getFunctionType(); switch (TF.TT.getWrapperKind(F)) { case Taint::WK_Warning: CB.setCalledFunction(F); IRB.CreateCall(TF.TT.TaintUnimplementedFn, IRB.CreateGlobalStringPtr(F->getName())); TF.setShadow(&CB, TF.TT.getZeroShadow(&CB)); return true; case Taint::WK_Discard: CB.setCalledFunction(F); TF.setShadow(&CB, TF.TT.getZeroShadow(&CB)); return true; case Taint::WK_Functional: CB.setCalledFunction(F); //FIXME: // visitOperandShadowInst(CS); return true; case Taint::WK_Memcmp: { // int memcmp(const void *s1, const void *s2, size_t n) assert(CB.arg_size() == 3 && !FT->getReturnType()->isVoidTy()); TransformedFunction CustomFn = TF.TT.getCustomFunctionType(FT); FunctionCallee DfswFn = TF.TT.Mod->getOrInsertFunction("__dfsw_memcmp", CustomFn.TransformedType); std::vector Args; // Add original arguments for (unsigned i = 0; i < FT->getNumParams(); i++) Args.push_back(CB.getArgOperand(i)); // Add shadow arguments (including return label pointer) addShadowArguments(F, CB, Args, IRB); CallInst *CustomCI = IRB.CreateCall(DfswFn, Args); // Load return shadow LoadInst *LabelLoad = IRB.CreateLoad(TF.TT.getShadowTy(FT->getReturnType()), TF.LabelReturnAlloca); TF.setShadow(CustomCI, LabelLoad); CB.replaceAllUsesWith(CustomCI); CB.eraseFromParent(); return true; } case Taint::WK_Strcmp: { // int strcmp(const char *s1, const char *s2) assert(CB.arg_size() == 2 && !FT->getReturnType()->isVoidTy()); TransformedFunction CustomFn = TF.TT.getCustomFunctionType(FT); FunctionCallee DfswFn = TF.TT.Mod->getOrInsertFunction("__dfsw_strcmp", CustomFn.TransformedType); std::vector Args; for (unsigned i = 0; i < FT->getNumParams(); i++) Args.push_back(CB.getArgOperand(i)); addShadowArguments(F, CB, Args, IRB); CallInst *CustomCI = IRB.CreateCall(DfswFn, Args); LoadInst *LabelLoad = IRB.CreateLoad(TF.TT.getShadowTy(FT->getReturnType()), TF.LabelReturnAlloca); TF.setShadow(CustomCI, LabelLoad); CB.replaceAllUsesWith(CustomCI); CB.eraseFromParent(); return true; } case Taint::WK_Strncmp: { // int strncmp(const char *s1, const char *s2, size_t n) assert(CB.arg_size() == 3 && !FT->getReturnType()->isVoidTy()); TransformedFunction CustomFn = TF.TT.getCustomFunctionType(FT); FunctionCallee DfswFn = TF.TT.Mod->getOrInsertFunction("__dfsw_strncmp", CustomFn.TransformedType); std::vector Args; for (unsigned i = 0; i < FT->getNumParams(); i++) Args.push_back(CB.getArgOperand(i)); addShadowArguments(F, CB, Args, IRB); CallInst *CustomCI = IRB.CreateCall(DfswFn, Args); LoadInst *LabelLoad = IRB.CreateLoad(TF.TT.getShadowTy(FT->getReturnType()), TF.LabelReturnAlloca); TF.setShadow(CustomCI, LabelLoad); CB.replaceAllUsesWith(CustomCI); CB.eraseFromParent(); return true; } case Taint::WK_Strchr: { // char *strchr(char *s, int c) assert(CB.arg_size() == 2 && !FT->getReturnType()->isVoidTy()); TransformedFunction CustomFn = TF.TT.getCustomFunctionType(FT); FunctionCallee DfswFn = TF.TT.Mod->getOrInsertFunction("__dfsw_strchr", CustomFn.TransformedType); std::vector Args; for (unsigned i = 0; i < FT->getNumParams(); i++) Args.push_back(CB.getArgOperand(i)); addShadowArguments(F, CB, Args, IRB); CallInst *CustomCI = IRB.CreateCall(DfswFn, Args); LoadInst *LabelLoad = IRB.CreateLoad(TF.TT.getShadowTy(FT->getReturnType()), TF.LabelReturnAlloca); TF.setShadow(CustomCI, LabelLoad); CB.replaceAllUsesWith(CustomCI); CB.eraseFromParent(); return true; } case Taint::WK_Strrchr: { // char *strrchr(char *s, int c) assert(CB.arg_size() == 2 && !FT->getReturnType()->isVoidTy()); TransformedFunction CustomFn = TF.TT.getCustomFunctionType(FT); FunctionCallee DfswFn = TF.TT.Mod->getOrInsertFunction("__dfsw_strrchr", CustomFn.TransformedType); std::vector Args; for (unsigned i = 0; i < FT->getNumParams(); i++) Args.push_back(CB.getArgOperand(i)); addShadowArguments(F, CB, Args, IRB); CallInst *CustomCI = IRB.CreateCall(DfswFn, Args); LoadInst *LabelLoad = IRB.CreateLoad(TF.TT.getShadowTy(FT->getReturnType()), TF.LabelReturnAlloca); TF.setShadow(CustomCI, LabelLoad); CB.replaceAllUsesWith(CustomCI); CB.eraseFromParent(); return true; } case Taint::WK_Strstr: { // char *strstr(char *haystack, char *needle) assert(CB.arg_size() == 2 && !FT->getReturnType()->isVoidTy()); TransformedFunction CustomFn = TF.TT.getCustomFunctionType(FT); FunctionCallee DfswFn = TF.TT.Mod->getOrInsertFunction("__dfsw_strstr", CustomFn.TransformedType); std::vector Args; for (unsigned i = 0; i < FT->getNumParams(); i++) Args.push_back(CB.getArgOperand(i)); addShadowArguments(F, CB, Args, IRB); CallInst *CustomCI = IRB.CreateCall(DfswFn, Args); LoadInst *LabelLoad = IRB.CreateLoad(TF.TT.getShadowTy(FT->getReturnType()), TF.LabelReturnAlloca); TF.setShadow(CustomCI, LabelLoad); CB.replaceAllUsesWith(CustomCI); CB.eraseFromParent(); return true; } case Taint::WK_Prefixof: { // int prefixof(const char *str, const char *prefix) assert(CB.arg_size() == 2 && !FT->getReturnType()->isVoidTy()); TransformedFunction CustomFn = TF.TT.getCustomFunctionType(FT); FunctionCallee DfswFn = TF.TT.Mod->getOrInsertFunction("__dfsw_prefixof", CustomFn.TransformedType); std::vector Args; for (unsigned i = 0; i < FT->getNumParams(); i++) Args.push_back(CB.getArgOperand(i)); addShadowArguments(F, CB, Args, IRB); CallInst *CustomCI = IRB.CreateCall(DfswFn, Args); LoadInst *LabelLoad = IRB.CreateLoad(TF.TT.getShadowTy(FT->getReturnType()), TF.LabelReturnAlloca); TF.setShadow(CustomCI, LabelLoad); CB.replaceAllUsesWith(CustomCI); CB.eraseFromParent(); return true; } case Taint::WK_Suffixof: { // int suffixof(const char *str, const char *suffix) assert(CB.arg_size() == 2 && !FT->getReturnType()->isVoidTy()); TransformedFunction CustomFn = TF.TT.getCustomFunctionType(FT); FunctionCallee DfswFn = TF.TT.Mod->getOrInsertFunction("__dfsw_suffixof", CustomFn.TransformedType); std::vector Args; for (unsigned i = 0; i < FT->getNumParams(); i++) Args.push_back(CB.getArgOperand(i)); addShadowArguments(F, CB, Args, IRB); CallInst *CustomCI = IRB.CreateCall(DfswFn, Args); LoadInst *LabelLoad = IRB.CreateLoad(TF.TT.getShadowTy(FT->getReturnType()), TF.LabelReturnAlloca); TF.setShadow(CustomCI, LabelLoad); CB.replaceAllUsesWith(CustomCI); CB.eraseFromParent(); return true; } case Taint::WK_Strcat: { // char *strcat(char *dest, const char *src) assert(CB.arg_size() == 2 && !FT->getReturnType()->isVoidTy()); TransformedFunction CustomFn = TF.TT.getCustomFunctionType(FT); FunctionCallee DfswFn = TF.TT.Mod->getOrInsertFunction("__dfsw_strcat", CustomFn.TransformedType); std::vector Args; for (unsigned i = 0; i < FT->getNumParams(); i++) Args.push_back(CB.getArgOperand(i)); addShadowArguments(F, CB, Args, IRB); CallInst *CustomCI = IRB.CreateCall(DfswFn, Args); LoadInst *LabelLoad = IRB.CreateLoad(TF.TT.getShadowTy(FT->getReturnType()), TF.LabelReturnAlloca); TF.setShadow(CustomCI, LabelLoad); CB.replaceAllUsesWith(CustomCI); CB.eraseFromParent(); return true; } case Taint::WK_Strsub: { // char *strsub(char *s, size_t len) assert(CB.arg_size() == 3 && !FT->getReturnType()->isVoidTy()); TransformedFunction CustomFn = TF.TT.getCustomFunctionType(FT); FunctionCallee DfswFn = TF.TT.Mod->getOrInsertFunction("__dfsw_strsub", CustomFn.TransformedType); std::vector Args; for (unsigned i = 0; i < FT->getNumParams(); i++) Args.push_back(CB.getArgOperand(i)); addShadowArguments(F, CB, Args, IRB); CallInst *CustomCI = IRB.CreateCall(DfswFn, Args); LoadInst *LabelLoad = IRB.CreateLoad(TF.TT.getShadowTy(FT->getReturnType()), TF.LabelReturnAlloca); TF.setShadow(CustomCI, LabelLoad); CB.replaceAllUsesWith(CustomCI); CB.eraseFromParent(); return true; } case Taint::WK_Custom: // Don't try to handle invokes of custom functions, it's too complicated. // Instead, invoke the dfsw$ wrapper, which will in turn call the __dfsw_ // wrapper. CallInst *CI = dyn_cast(&CB); if (!CI) return false; FunctionType *FT = F->getFunctionType(); TransformedFunction CustomFn = TF.TT.getCustomFunctionType(FT); std::string CustomFName = "__dfsw_"; CustomFName += F->getName(); FunctionCallee CustomF = TF.TT.Mod->getOrInsertFunction(CustomFName, CustomFn.TransformedType); if (Function *CustomFn = dyn_cast(CustomF.getCallee())) { CustomFn->copyAttributesFrom(F); // Custom functions returning non-void will write to the return label. if (!FT->getReturnType()->isVoidTy()) { CustomFn->removeFnAttrs(TF.TT.ReadOnlyNoneAttrs); } } std::vector Args; // Adds non-variable arguments. auto *I = CB.arg_begin(); for (unsigned N = FT->getNumParams(); N != 0; ++I, --N) { Type *T = (*I)->getType(); FunctionType *ParamFT; if (isa(T) && (ParamFT = dyn_cast(T->getPointerElementType()))) { std::string TName = "dfst"; TName += utostr(FT->getNumParams() - N); TName += "$"; TName += F->getName(); Constant *Trampoline = TF.TT.getOrBuildTrampolineFunction(ParamFT, TName); Args.push_back(Trampoline); Args.push_back( IRB.CreateBitCast(*I, Type::getInt8PtrTy(*TF.TT.Ctx))); } else { Args.push_back(*I); } } // Adds shadow arguments. const unsigned ShadowArgStart = Args.size(); addShadowArguments(F, CB, Args, IRB); // Adds variable arguments. append_range(Args, drop_begin(CB.args(), FT->getNumParams())); CallInst *CustomCI = IRB.CreateCall(CustomF, Args); CustomCI->setCallingConv(CI->getCallingConv()); CustomCI->setAttributes(TransformFunctionAttributes( CustomFn, CI->getContext(), CI->getAttributes())); // Update the parameter attributes of the custom call instruction to // zero extend the shadow parameters. This is required for targets // which consider ShadowTy an illegal type. for (unsigned N = 0; N < FT->getNumParams(); N++) { const unsigned ArgNo = ShadowArgStart + N; if (CustomCI->getArgOperand(ArgNo)->getType() == TF.TT.PrimitiveShadowTy) { CustomCI->addParamAttr(ArgNo, Attribute::ZExt); } } // Loads the return value shadow and origin. Type *RetTy = FT->getReturnType(); if (!RetTy->isVoidTy()) { // we don't collapse shadow LoadInst *LabelLoad = IRB.CreateLoad(TF.TT.getShadowTy(RetTy), TF.LabelReturnAlloca); TF.setShadow(CustomCI, LabelLoad); } CI->replaceAllUsesWith(CustomCI); CI->eraseFromParent(); return true; } return false; } void TaintVisitor::visitIntrinsicCallBase(Function *F, CallBase &CB) { // filter some obvious ones StringRef FN = F->getName(); if (FN.startswith("llvm.va_") || // varabile length FN.startswith("llvm.gc") || // garbaage collection FN.startswith("llvm.experimental") || FN.startswith("llvm.lifetime") ) { return; } // intrinsic, check argument bool NeedsInstrumentation = false; for (unsigned I = 0, N = CB.arg_size(); I < N; ++I) { Value *Shadow = TF.getShadow(CB.getArgOperand(I)); if (!TF.TT.isZeroShadow(Shadow)) { NeedsInstrumentation = true; break; } } if (!NeedsInstrumentation) return; // FIXME: track intrinsic return; } void TaintVisitor::visitCallBase(CallBase &CB) { if (CB.isInlineAsm()) { // FIXME: inline asm return; } // handle intrinsics Function *F = CB.getCalledFunction(); if (F && F->isIntrinsic()) { visitIntrinsicCallBase(F, CB); return; } // Calls to this function are synthesized in wrappers, and we shouldn't // instrument them. if (F == TF.TT.TaintVarargWrapperFn.getCallee()->stripPointerCasts()) return; IRBuilder<> IRB(&CB); // trace indirect call if (CB.getCalledFunction() == nullptr) { Value *Shadow = TF.getShadow(CB.getCalledOperand()); if (!TF.TT.isZeroShadow(Shadow)) IRB.CreateCall(TF.TT.TaintTraceIndirectCallFn, {Shadow}); } DenseMap::iterator UnwrappedFnIt = TF.TT.UnwrappedFnMap.find(CB.getCalledOperand()); if (UnwrappedFnIt != TF.TT.UnwrappedFnMap.end()) { if (visitWrappedCallBase(UnwrappedFnIt->second, CB)) return; } // reset IRB IRB.SetInsertPoint(&CB); FunctionType *FT = CB.getFunctionType(); const DataLayout &DL = getDataLayout(); // Stores argument shadows. unsigned ArgOffset = 0; for (unsigned I = 0, N = FT->getNumParams(); I != N; ++I) { unsigned Size = DL.getTypeAllocSize(TF.TT.getShadowTy(FT->getParamType(I))); // Stop storing if arguments' size overflows. Inside a function, arguments // after overflow have zero shadow values. if (ArgOffset + Size > ArgTLSSize) break; Value *Arg = CB.getArgOperand(I); auto *GV = dyn_cast(Arg->stripPointerCasts()); Value *Shadow = GV ? TF.getShadowForGlobal(GV, IRB) : TF.getShadow(Arg); IRB.CreateAlignedStore(Shadow, TF.getArgTLS(FT->getParamType(I), ArgOffset, IRB), ShadowTLSAlignment); ArgOffset += alignTo(Size, ShadowTLSAlignment); } Instruction *Next = nullptr; if (!CB.getType()->isVoidTy()) { if (InvokeInst *II = dyn_cast(&CB)) { if (II->getNormalDest()->getSinglePredecessor()) { Next = &II->getNormalDest()->front(); } else { BasicBlock *NewBB = SplitEdge(II->getParent(), II->getNormalDest(), &TF.DT); Next = &NewBB->front(); } } else { assert(CB.getIterator() != CB.getParent()->end()); Next = CB.getNextNode(); } // Don't emit the epilogue for musttail call returns. if (isa(CB) && cast(CB).isMustTailCall()) return; // Loads the return value shadow. IRBuilder<> NextIRB(Next); unsigned Size = DL.getTypeAllocSize(TF.TT.getShadowTy(&CB)); if (Size > RetvalTLSSize) { // Set overflowed return shadow to be zero. TF.setShadow(&CB, TF.TT.getZeroShadow(&CB)); } else { LoadInst *LI = NextIRB.CreateAlignedLoad( TF.TT.getShadowTy(&CB), TF.getRetvalTLS(CB.getType(), NextIRB), ShadowTLSAlignment, "_dfsret"); TF.SkipInsts.insert(LI); TF.setShadow(&CB, LI); TF.NonZeroChecks.push_back(LI); } } } void TaintVisitor::visitPHINode(PHINode &PN) { Type *ShadowTy = TF.TT.getShadowTy(&PN); PHINode *ShadowPN = PHINode::Create(ShadowTy, PN.getNumIncomingValues(), "", &PN); // Give the shadow phi node valid predecessors to fool SplitEdge into working. Value *UndefShadow = UndefValue::get(ShadowTy); for (BasicBlock *BB : PN.blocks()) ShadowPN->addIncoming(UndefShadow, BB); TF.setShadow(&PN, ShadowPN); TF.PHIFixups.push_back({&PN, ShadowPN}); } static inline bool isLoopLatch(const BasicBlock *BB, const BasicBlock *Header) { const BasicBlock *Succ = nullptr; SmallVector Visited; while (BB != Header) { Visited.push_back(BB); if ((Succ = BB->getSingleSuccessor()) == nullptr) return false; BB = Succ; if (Visited.end() != std::find(Visited.begin(), Visited.end(), BB)) return false; // found a cycle } return true; } void TaintFunction::visitCondition(Value *Condition, Instruction *I) { IRBuilder<> IRB(I); // get operand Value *Shadow = getShadow(Condition); uint8_t flag = 0; if (ClTraceLoop && isa(I)) { // check loop exit and latch BasicBlock *BB = I->getParent(); Loop *L = LI->getLoopFor(BB); if (L) { BranchInst *BI = cast(I); BasicBlock *TB = I->getSuccessor(0); // true branch BasicBlock *FB = I->getSuccessor(1); // false branch if (isLoopLatch(TB, L->getHeader())) // True branch loop latch flag |= TrueBranchLoopLatch; // return to the loop header if (isLoopLatch(FB, L->getHeader())) // False branch loop latch flag |= FalseBranchLoopLatch; // return to the loop header if (!L->contains(TB)) // True branch loop exit flag |= TrueBranchLoopExit; if (!L->contains(FB)) // False branch loop exit flag |= FalseBranchLoopExit; } } // we are not interested if the condition is not tainted, // except for loop exit if (TT.isZeroShadow(Shadow) && (flag & LoopExitBranch) == 0) return; uint32_t cid = TT.getInstructionId(I); if (cid == TT.InvalidInstructionId) return; // XXX: forget about loop? ConstantInt *LF = ConstantInt::get(TT.Int8Ty, flag); ConstantInt *CID = ConstantInt::get(TT.Int32Ty, cid); IRB.CreateCall(TT.TaintTraceCondFn, {Shadow, Condition, LF, CID}); } void TaintVisitor::visitBranchInst(BranchInst &BR) { if (BR.getMetadata("nosanitize")) return; if (BR.isUnconditional()) return; TF.visitCondition(BR.getCondition(), &BR); } namespace { class TaintPass : public PassInfoMixin { private: std::vector ABIListFiles; public: TaintPass( const std::vector &ABIListFiles = std::vector()) : ABIListFiles(ABIListFiles) {} PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM) { if (Taint(ABIListFiles).runImpl(M)) { return PreservedAnalyses::none(); } return PreservedAnalyses::all(); } static bool isRequired() { return true; } }; } extern "C" ::llvm::PassPluginLibraryInfo LLVM_ATTRIBUTE_WEAK llvmGetPassPluginInfo() { return {LLVM_PLUGIN_API_VERSION, "TaintPass", "v1.1", [](PassBuilder &PB) { PB.registerOptimizerLastEPCallback( [](ModulePassManager &MPM, OptimizationLevel OL) { MPM.addPass(TaintPass()); }); PB.registerPipelineParsingCallback( [](StringRef Name, ModulePassManager &MPM, ArrayRef) { if (Name == "taint") { MPM.addPass(TaintPass()); return true; } return false; }); }}; } ================================================ FILE: parsers/CMakeLists.txt ================================================ set(CMAKE_POSITION_INDEPENDENT_CODE ON) set(CMAKE_CXX_STANDARD 17) find_package(boost_container CONFIG) if (NOT boost_container_FOUND) message(FATAL_ERROR "Failed to locate Boost") endif() ## parser add_library(rgd-parser STATIC rgd-parser.cpp) target_include_directories(rgd-parser PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../runtime ${Boost_INCLUDE_DIRS} ) target_compile_options(rgd-parser PRIVATE -O3 -g -mcx16 -march=native -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free ) target_link_libraries(rgd-parser PRIVATE Boost::container ) ================================================ FILE: parsers/rgd-parser.cpp ================================================ #include "dfsan/dfsan.h" #include "ast.h" #include "task.h" #include "union_find.h" #include "parse-rgd.h" #include using namespace rgd; #ifndef DEBUG #define DEBUG 0 #endif #if DEBUG #define DEBUGF(_str...) do { fprintf(stderr, _str); } while (0) #else #undef DEBUGF #define DEBUGF(_str...) do { } while (0) #endif #ifndef WARNF #define WARNF(_str...) do { fprintf(stderr, _str); } while (0) // #define WARNF(x...) do { \ // SAYF(cYEL "[!] " cBRI "WARNING: " cRST x); \ // SAYF(cRST "\n"); \ // } while (0) #endif #define NEED_OFFLINE 0 #if defined(__GNUC__) static inline bool (likely)(bool x) { return __builtin_expect((x), true); } static inline bool (unlikely)(bool x) { return __builtin_expect((x), false); } #else static inline bool (likely)(bool x) { return x; } static inline bool (unlikely)(bool x) { return x; } #endif static const std::unordered_map > OP_MAP { {__dfsan::Extract, {rgd::Extract, "extract"}}, {__dfsan::Trunc, {rgd::Extract, "extract"}}, {__dfsan::Concat, {rgd::Concat, "concat"}}, {__dfsan::ZExt, {rgd::ZExt, "zext"}}, {__dfsan::SExt, {rgd::SExt, "sext"}}, {__dfsan::Add, {rgd::Add, "add"}}, {__dfsan::Sub, {rgd::Sub, "sub"}}, {__dfsan::Mul, {rgd::Mul, "mul"}}, {__dfsan::UDiv, {rgd::UDiv, "udiv"}}, {__dfsan::SDiv, {rgd::SDiv, "sdiv"}}, {__dfsan::URem, {rgd::URem, "urem"}}, {__dfsan::SRem, {rgd::SRem, "srem"}}, {__dfsan::Shl, {rgd::Shl, "shl"}}, {__dfsan::LShr, {rgd::LShr, "lshr"}}, {__dfsan::AShr, {rgd::AShr, "ashr"}}, {__dfsan::And, {rgd::And, "and"}}, {__dfsan::Or, {rgd::Or, "or"}}, {__dfsan::Xor, {rgd::Xor, "xor"}}, // relational comparisons #define RELATIONAL_ICMP(cmp) (__dfsan::ICmp | (cmp << 8)) {RELATIONAL_ICMP(__dfsan::bveq), {rgd::Equal, "equal"}}, {RELATIONAL_ICMP(__dfsan::bvneq), {rgd::Distinct, "distinct"}}, {RELATIONAL_ICMP(__dfsan::bvugt), {rgd::Ugt, "ugt"}}, {RELATIONAL_ICMP(__dfsan::bvuge), {rgd::Uge, "uge"}}, {RELATIONAL_ICMP(__dfsan::bvult), {rgd::Ult, "ult"}}, {RELATIONAL_ICMP(__dfsan::bvule), {rgd::Ule, "ule"}}, {RELATIONAL_ICMP(__dfsan::bvsgt), {rgd::Sgt, "sgt"}}, {RELATIONAL_ICMP(__dfsan::bvsge), {rgd::Sge, "sge"}}, {RELATIONAL_ICMP(__dfsan::bvslt), {rgd::Slt, "slt"}}, {RELATIONAL_ICMP(__dfsan::bvsle), {rgd::Sle, "sle"}}, #undef RELATIONAL_ICMP }; static inline bool is_rel_cmp(uint16_t op, __dfsan::predicate pred) { return ((op & 0xff) == __dfsan::ICmp) && ((op >> 8) == pred); } static inline bool eval_icmp(uint16_t op, uint64_t op1, uint64_t op2) { if ((op & 0xff) == __dfsan::ICmp) { switch (op >> 8) { case __dfsan::bveq: return op1 == op2; case __dfsan::bvneq: return op1 != op2; case __dfsan::bvugt: return op1 > op2; case __dfsan::bvuge: return op1 >= op2; case __dfsan::bvult: return op1 < op2; case __dfsan::bvule: return op1 <= op2; case __dfsan::bvsgt: return (int64_t)op1 > (int64_t)op2; case __dfsan::bvsge: return (int64_t)op1 >= (int64_t)op2; case __dfsan::bvslt: return (int64_t)op1 < (int64_t)op2; case __dfsan::bvsle: return (int64_t)op1 <= (int64_t)op2; default: return false; } } return false; } static void printAst(FILE* f, const rgd::AstNode *node, int indent) { fprintf(f, "(%s, ", rgd::AstKindName[node->kind()]); fprintf(f, "%d, ", node->label()); fprintf(f, "%d, ", node->bits()); for(int i = 0; i < node->children_size(); i++) { printAst(f, &node->children(i), indent + 1); if (i != node->children_size() - 1) { fprintf(f, ", "); } } fprintf(f, ")\n"); } int RGDAstParser::restart(std::vector &inputs) { // save a copy of the inputs inputs_cache = inputs; // clear caches memcmp_cache_.clear(); // inherited from ASTParser root_expr_cache.clear(); constraint_cache.clear(); ast_size_cache.clear(); nested_cmp_cache.clear(); concretize_node.clear(); branch_to_inputs.clear(); // reset data-flow dependencies input_size_ = 0; for (auto &i: inputs) { input_size_ += i.second; } data_flow_deps.reset(input_size_); for (auto &s: input_to_branches) { s.clear(); } input_to_branches.resize(input_size_); return 0; } uint32_t RGDAstParser::map_arg(uint32_t input_id, uint32_t offset, uint32_t length, constraint_t constraint) { uint32_t hash = 0; auto *buf = inputs_cache[input_id].first; for (uint32_t i = 0; i < length; ++i, ++offset) { uint8_t val = buf[offset]; uint32_t arg_index = 0; auto itr = constraint->local_map.find(offset); // FIXME: support input_id if (itr == constraint->local_map.end()) { arg_index = (uint32_t)constraint->input_args.size(); constraint->inputs.insert({offset, val}); constraint->local_map[offset] = arg_index; constraint->input_args.push_back(std::make_pair(true, 0)); // 0 is to be filled in the aggragation } else { arg_index = itr->second; } if (i == 0) { constraint->shapes[offset] = length; hash = rgd::xxhash(length * 8, rgd::Read, arg_index); } else { constraint->shapes[offset] = 0; } } return hash; } // this combines both AST construction and arg mapping [[gnu::hot]] bool RGDAstParser::do_uta_rel(dfsan_label label, rgd::AstNode *ret, constraint_t constraint, std::unordered_set &visited) { // needed for recursion? if (unlikely(label < CONST_OFFSET || label == __dfsan::kInitializingLabel)) { WARNF("invalid label: %d\n", label); return false; } dfsan_label_info *info = get_label_info(label); DEBUGF("do_uta_real: %u = (l1:%u, l2:%u, op:%u, size:%u, op1:%lu, op2:%lu)\n", label, info->l1, info->l2, info->op, info->size, info->op1.i, info->op2.i); // we can't really reuse AST nodes across constraints, // but we still need to avoid duplicate nodes within a constraint if (visited.count(label)) { // if a node has been visited, just record its label without expanding ret->set_label(label); ret->set_bits(info->size); return true; } // terminal node if (info->op == 0) { // input ret->set_kind(rgd::Read); ret->set_bits(8); ret->set_label(label); uint32_t input_id = info->op2.i; uint32_t offset = info->op1.i; // this check should have been done during label scanning // if (unlikely(offset >= buf_size)) { // WARNF("invalid offset: %lu >= %lu\n", offset, buf_size); // return false; // } ret->set_index(offset); // map arg uint32_t hash = map_arg(input_id, offset, 1, constraint); ret->set_hash(hash); #if NEED_OFFLINE std::string val; rgd::buf_to_hex_string(&buf[offset], 1, val); ret->set_value(std::move(val)); ret->set_name("read"); #endif return true; } else if (info->op == __dfsan::Load) { ret->set_kind(rgd::Read); ret->set_bits(info->l2 * 8); ret->set_label(label); uint32_t input_id = get_label_info(info->l1)->op2.i; uint32_t offset = get_label_info(info->l1)->op1.i; // this check should have been done during label scanning // if (unlikely(offset + info->l2 > buf_size)) { // WARNF("invalid offset: %lu + %u > %lu\n", offset, info->l2, buf_size); // return false; // } ret->set_index(offset); // map arg uint32_t hash = map_arg(input_id, offset, info->l2, constraint); ret->set_hash(hash); #if NEED_OFFLINE std::string val; rgd::buf_to_hex_string(&buf[offset], info->l2, val); ret->set_value(std::move(val)); ret->set_name("read"); #endif return true; } else if (info->op == __dfsan::fmemcmp) { rgd::AstNode *s1 = ret->add_children(); if (unlikely(s1 == nullptr)) { WARNF("failed to add children\n"); return false; } if (info->l1 >= CONST_OFFSET) { if (!do_uta_rel(info->l1, s1, constraint, visited)) { return false; } visited.insert(info->l1); } else { // s1 is a constant array s1->set_kind(rgd::Constant); s1->set_bits(info->size * 8); s1->set_label(0); // use constant args to pass the array auto itr = memcmp_cache_.find(label); if (unlikely(itr == memcmp_cache_.end())) { WARNF("memcmp target not found for label %u\n", label); return false; } uint32_t arg_index = (uint32_t)constraint->input_args.size(); s1->set_index(arg_index); uint16_t chunks = info->size / 8; uint16_t remain = info->size % 8; uint64_t val = 0; for (uint16_t i = 0; i < chunks; i++) { val = *(uint64_t*)&(itr->second.get()[i * 8]); constraint->input_args.push_back(std::make_pair(false, val)); constraint->const_num += 1; DEBUGF("memcmp constant chunk %d = 0x%lx\n", i, val); } if (remain) { val = 0; for (uint16_t i = 0; i < remain; i++) { val |= (uint64_t)itr->second.get()[chunks * 8 + i] << (i * 8); } constraint->input_args.push_back(std::make_pair(false, val)); constraint->const_num += 1; DEBUGF("memcmp constant remain = %lu\n", val); } uint32_t hash = rgd::xxhash(info->size, rgd::Constant, arg_index); s1->set_hash(hash); #if NEED_OFFLINE std::string val; rgd::buf_to_hex_string(itr->second, info->size, val); ret->set_value(std::move(val)); ret->set_name("constant"); #endif } rgd::AstNode *s2 = ret->add_children(); if (unlikely(s2 == nullptr)) { WARNF("failed to add children\n"); return false; } if (!do_uta_rel(info->l2, s2, constraint, visited)) { return false; } visited.insert(info->l2); ret->set_kind(rgd::Memcmp); ret->set_bits(1); ret->set_label(label); uint32_t hash = rgd::xxhash(s1->hash(), rgd::Memcmp, s2->hash()); ret->set_hash(hash); #if NEED_OFFLINE ret->set_name("memcmp"); #endif return true; } else if (info->op == __dfsan::fatoi) { if (unlikely(info->l1 != 0 || info->l2 < CONST_OFFSET)) { WARNF("invalid atoi label %u\n", label); return false; } dfsan_label_info *src = get_label_info(info->l2); if (unlikely(src->op != __dfsan::Load)) { WARNF("invalid atoi source label %u, op = %u\n", info->l2, src->op); return false; } visited.insert(info->l2); uint32_t input_id = get_label_info(src->l1)->op2.i; uint32_t offset = get_label_info(src->l1)->op1.i; // this check should have been done during label scanning // if (unlikely(offset >= buf_size)) { // WARNF("invalid offset: %lu >= %lu\n", offset, buf_size); // return false; // } ret->set_bits(info->size); ret->set_label(label); ret->set_index(offset); // special handling for atoi, we are introducing the result/output of // atoi as fake inputs, and solve constraints over the output, // once solved, we convert it back to string // however, because the input is fake, we need to map it specially ret->set_kind(rgd::Read); auto itr = constraint->local_map.find(offset); // FIXME: support input_id if (itr != constraint->local_map.end()) { WARNF("atoi inputs should not be involved in other constraints\n"); return false; } uint32_t hash = 0; uint32_t length = info->size / 8; // bits to bytes // record the offset, base, and original length constraint->atoi_info[offset] = std::make_tuple(length, (uint32_t)info->op1.i, (uint32_t)info->op2.i); for (uint32_t i = 0; i < length; ++i, ++offset) { uint8_t val = 0; // XXX: use 0 as initial value? // because this is fake input, we always map it to a new index uint32_t arg_index = (uint32_t)constraint->input_args.size(); constraint->inputs.insert({offset, val}); constraint->local_map[offset] = arg_index; // FIXME: support input_id constraint->input_args.push_back(std::make_pair(true, 0)); // 0 is to be filled in the aggragation if (i == 0) { constraint->shapes[offset] = length; // from solver's perspective, atoi and read are the same // they both introduce a new symbolic input as arg_index hash = rgd::xxhash(length * 8, rgd::Read, arg_index); } else { constraint->shapes[offset] = 0; } } ret->set_hash(hash); #if NEED_OFFLINE ret->set_name("atoi"); #endif return true; } else if (info->op == __dfsan::fsize) { // do nothing now WARNF("fsize not supported yet\n"); return false; } // common ops, make sure no special ops auto op_itr = OP_MAP.find(info->op); if (op_itr == OP_MAP.end()) { WARNF("invalid op: %u\n", info->op); return false; } ret->set_kind(op_itr->second.first); ret->set_bits(info->size); ret->set_label(label); #if NEED_OFFLINE ret->set_name(op_itr->second.second); #endif // record op constraint->ops[ret->kind()] = true; // in case we needs concretization uint8_t needs_concretization = 0; auto node_itr = concretize_node.find(label); if (node_itr != concretize_node.end()) { needs_concretization = node_itr->second; } // now we visit the children rgd::AstNode *left = ret->add_children(); if (unlikely(left == nullptr)) { WARNF("failed to add children\n"); return false; } if (likely(needs_concretization != 1) && (info->l1 >= CONST_OFFSET)) { if (!do_uta_rel(info->l1, left, constraint, visited)) { return false; } visited.insert(info->l1); } else { if (unlikely(needs_concretization)) { if (unlikely(!rgd::isRelationalKind(ret->kind()))) { WARNF("invalid kind for concretization %u\n", ret->kind()); return false; } } // constant left->set_kind(rgd::Constant); left->set_label(0); uint32_t size = info->size; // size of concat the sum of the two operands // to get the size of the constant, we need to subtract the size // of the other operand if (info->op == __dfsan::Concat) { if (unlikely(info->l2 == 0)) { WARNF("invalid concat node %u\n", info->l2); return false; } size -= get_label_info(info->l2)->size; } left->set_bits(size); // map args uint32_t arg_index = (uint32_t)constraint->input_args.size(); left->set_index(arg_index); constraint->input_args.push_back(std::make_pair(false, info->op1.i)); constraint->const_num += 1; uint32_t hash = rgd::xxhash(size, rgd::Constant, arg_index); left->set_hash(hash); #if NEED_OFFLINE left->set_value(std::to_string(info->op1.i)); left->set_name("constant"); #endif } // unary ops if (info->op == __dfsan::ZExt || info->op == __dfsan::SExt || info->op == __dfsan::Extract || info->op == __dfsan::Trunc) { uint32_t hash = rgd::xxhash(info->size, ret->kind(), left->hash()); ret->set_hash(hash); uint64_t offset = info->op == __dfsan::Extract ? info->op2.i : 0; ret->set_index(offset); return true; } rgd::AstNode *right = ret->add_children(); if (unlikely(right == nullptr)) { WARNF("failed to add children\n"); return false; } if (likely(needs_concretization != 2) && (info->l2 >= CONST_OFFSET)) { if (!do_uta_rel(info->l2, right, constraint, visited)) { return false; } visited.insert(info->l2); } else { if (unlikely(needs_concretization)) { if (unlikely(!rgd::isRelationalKind(ret->kind()))) { WARNF("invalid kind for concretization %u\n", ret->kind()); return false; } } // constant right->set_kind(rgd::Constant); right->set_label(0); uint32_t size = info->size; // size of concat the sum of the two operands // to get the size of the constant, we need to subtract the size // of the other operand if (info->op == __dfsan::Concat) { if (unlikely(info->l1 == 0)) { WARNF("invalid concat node %u\n", info->l1); return false; } size -= get_label_info(info->l1)->size; } right->set_bits(size); // map args uint32_t arg_index = (uint32_t)constraint->input_args.size(); right->set_index(arg_index); constraint->input_args.push_back(std::make_pair(false, info->op2.i)); constraint->const_num += 1; uint32_t hash = rgd::xxhash(size, rgd::Constant, arg_index); right->set_hash(hash); #if NEED_OFFLINE right->set_value(std::to_string(info->op1.i)); right->set_name("constant"); #endif } // record comparison operands if (rgd::isRelationalKind(ret->kind())) { constraint->op1 = info->op1.i; constraint->op2 = info->op2.i; } // binary ops, we don't really care about comparison ops in jigsaw, // as long as the operands are the same, we can reuse the AST/function uint32_t kind = rgd::isRelationalKind(ret->kind()) ? rgd::Bool : ret->kind(); uint32_t hash = rgd::xxhash(left->hash(), (kind << 16) | ret->bits(), right->hash()); ret->set_hash(hash); return true; } [[gnu::hot]] RGDAstParser::constraint_t RGDAstParser::parse_constraint(dfsan_label label) { DEBUGF("constructing constraint for label %u\n", label); // make sure root is a comparison node // XXX: root should never go oob? dfsan_label_info *info = get_label_info(label); if (unlikely(((info->op & 0xff) != __dfsan::ICmp) && (info->op != __dfsan::fmemcmp))) { WARNF("invalid root node %u, non-comparison root op: %u\n", label, info->op); return nullptr; } // retrieve the ast size if (unlikely(ast_size_cache.size() <= label)) { WARNF("invalid label %u, larger than ast_size_cache: %lu\n", label, ast_size_cache.size()); return nullptr; } auto size = ast_size_cache.at(label); if (unlikely(size == 0)) { WARNF("invalid label %u, ast_size_cache is 0\n", label); return nullptr; } std::unordered_set visited; try { constraint_t constraint = std::make_shared(size); if (!do_uta_rel(label, constraint->ast.get(), constraint, visited)) { return nullptr; } return constraint; } catch (std::bad_alloc &e) { WARNF("failed to allocate memory for constraint\n"); return nullptr; } catch (std::out_of_range &e) { WARNF("AST %u goes out of range at %s\n", label, e.what()); return nullptr; } } [[gnu::hot]] task_t RGDAstParser::construct_task(const clause_t &clause) { task_t task = std::make_shared(); for (auto const& node: clause) { auto itr = constraint_cache.find(node->label()); if (itr != constraint_cache.end()) { task->add_constraint(itr->second, node->kind()); continue; } // save the comparison op because we may have negated it // during transformation constraint_t constraint = parse_constraint(node->label()); // to maximize the resuability of the AST, the relational operator // is recorded elsewhere if (likely(constraint != nullptr)) { task->add_constraint(constraint, node->kind()); constraint_cache.insert({node->label(), constraint}); } } if (!task->empty()) { task->finalize(); return task; } return nullptr; } // sometimes llvm will zext bool dfsan_label RGDAstParser::strip_zext(dfsan_label label) { dfsan_label_info *info = get_label_info(label); while (info->op == __dfsan::ZExt) { dfsan_label child = info->l1; info = get_label_info(child); if (info->size == 1) { // extending a boolean value return child; } else if ((info->op & 0xff) == __dfsan::ICmp || info->op == __dfsan::fmemcmp) { // extending the result of icmp or memcmp return child; } } return label; } [[gnu::hot]] int RGDAstParser::find_roots(dfsan_label label, AstNode *ret, std::unordered_set &subroots) { // assume the root label has been checked by the caller // if (label < CONST_OFFSET || label == kInitializingLabel) { // WARNF("invalid label: %d\n", label); // return INVALID_NODE; // } std::vector stack; dfsan_label root = label; dfsan_label prev = 0; std::vector node_stack; AstNode *root_node = ret; std::unordered_set visited; try{ while (root != 0 || !stack.empty()) { if (root != 0) { // check if the node has been visited before if (visited.find(root) != visited.end()) { // already visited, skip the subtree prev = root; root = 0; continue; } // mark to be visit in the future, for in-order and post-order visitors stack.push_back(root); node_stack.push_back(root_node); auto *info = get_label_info(root); if (nested_cmp_cache[info->l1] == 0) { // no nested comparison in the left child, stop going down // again, we only collect a partial AST with comparison nodes as leafs // so the traversal should stop before reaching any actual leaf node root = 0; } else { root = strip_zext(info->l1); if (root) { // create a child node before going down root_node = root_node->add_children(); if (unlikely(root_node == nullptr)) { WARNF("failed to add children\n"); return INVALID_NODE; } } } } else { // we have reached some leaf node, going up the tree auto curr = stack.back(); auto info = get_label_info(curr); auto zsl2 = strip_zext(info->l2); if (nested_cmp_cache[zsl2] > 0 && prev != zsl2) { // we have a right child, and we haven't visited it yet, // and there is a nested comparison, going down the right tree root = zsl2; root_node = node_stack.back()->add_children(); if (unlikely(root_node == nullptr)) { WARNF("failed to add children\n"); return INVALID_NODE; } } else { DEBUGF("label %d, l1 %d, l2 %d, op %d, size %d, op1 %ld, op2 %ld\n", curr, info->l1, info->l2, info->op, info->size, info->op1.i, info->op2.i); // both children nodes have been visited, process the node (post-order) auto node = node_stack.back(); if (info->op == __dfsan::Not) { DEBUGF("simplify not: %d, %d\n", info->l2, info->size); if (unlikely(node->children_size() != 1)) { WARNF("child node size != 1\n"); return INVALID_NODE; } if (unlikely(info->size != 1)) { WARNF("info size != 1\n"); return INVALID_NODE; } rgd::AstNode *child = node->mutable_children(0); node->set_bits(1); if (child->kind() == rgd::Bool) { node->set_kind(rgd::Bool); node->set_boolvalue(!child->boolvalue()); node->clear_children(); } else { node->set_kind(rgd::LNot); } } else if (info->op == __dfsan::And) { // if And apprears, it must be LAnd, try to simplify DEBUGF("simplify land: %d LAnd %d, %d\n", info->l1, info->l2, info->size); if (unlikely(node->children_size() == 0)) { WARNF("child node size == 0\n"); return INVALID_NODE; } if (unlikely(info->size != 1)) { WARNF("info size != 1\n"); return INVALID_NODE; } uint32_t child = 0; rgd::AstNode *left = nullptr; rgd::AstNode *right = nullptr; if (nested_cmp_cache[info->l1] > 0) { left = node->mutable_children(0); child = 1; // if left child exists, rhs will be child 1 } if (nested_cmp_cache[info->l2] > 0) { right = node->mutable_children(child); } node->set_bits(1); if (unlikely(info->l1 == 0)) { // lhs is a constant if (info->op1.i == 0) { // 0 LAnd x = 0 node->set_kind(rgd::Bool); node->set_boolvalue(0); node->clear_children(); } else if (info->op1.i == 1) { // 1 LAnd x = x if (unlikely(right == nullptr)) { WARNF("right child is null\n"); return INVALID_NODE; } node->CopyFrom(*right); } else { WARNF("invalid constant %ld\n", info->op1.i); return INVALID_NODE; } } else { if (unlikely(left == nullptr)) { WARNF("left child is null\n"); return INVALID_NODE; } if (unlikely(right == nullptr)) { WARNF("right child is null\n"); return INVALID_NODE; } // check for constant if (left->kind() == rgd::Bool) { if (left->boolvalue() == 0) { // 0 LAnd x = 0 node->set_kind(rgd::Bool); node->set_boolvalue(0); node->clear_children(); } else if (right->kind() == rgd::Bool) { // both lhs and rhs are constants node->set_kind(rgd::Bool); node->set_boolvalue(right->boolvalue()); // 1 LAnd b = b node->clear_children(); } else { // 1 LAnd x = x // lhs is 1, rhs is not node->CopyFrom(*right); } } else if (right->kind() == rgd::Bool) { // lhs is not a constant, check rhs if (right->boolvalue() == 0) { // x LAnd 0 = 0 node->set_kind(rgd::Bool); node->set_boolvalue(0); node->clear_children(); } else { // x LAnd 1 = x // rhs is 1, lhs is not node->CopyFrom(*left); } } else { // both sides are symbolic node->set_kind(rgd::LAnd); } } } else if (info->op == __dfsan::Or) { DEBUGF("simplify lor: %d LOr %d, %d\n", info->l1, info->l2, info->size); if (unlikely(node->children_size() == 0)) { WARNF("child node size == 0\n"); return INVALID_NODE; } if (unlikely(info->size != 1)) { WARNF("info size != 1\n"); return INVALID_NODE; } uint32_t child = 0; rgd::AstNode *left = nullptr; rgd::AstNode *right = nullptr; if (nested_cmp_cache[info->l1] > 0) { left = node->mutable_children(0); child = 1; // if left child exists, rhs will be child 1 } if (nested_cmp_cache[info->l2] > 0) { right = node->mutable_children(child); } node->set_bits(1); if (unlikely(info->l1 == 0)) { // lhs is a constant if (info->op1.i == 1) { // x LOr 1 = 1 node->set_kind(rgd::Bool); node->set_boolvalue(1); node->clear_children(); } else if (info->op1.i == 0) { // 0 LOr x = x if (unlikely(right == nullptr)) { WARNF("right child is null\n"); return INVALID_NODE; } node->CopyFrom(*right); } else { WARNF("invalid constant %ld\n", info->op1.i); return INVALID_NODE; } } else { if (unlikely(left == nullptr)) { WARNF("left child is null\n"); return INVALID_NODE; } if (unlikely(right == nullptr)) { WARNF("right child is null\n"); return INVALID_NODE; } // check for constant if (left->kind() == rgd::Bool) { if (left->boolvalue() == 1) { // 1 LOr x = 1 node->set_kind(rgd::Bool); node->set_boolvalue(1); node->clear_children(); } else if (right->kind() == rgd::Bool) { // both lhs and rhs are constants node->set_kind(rgd::Bool); node->set_boolvalue(right->boolvalue()); // 0 LOr b = b node->clear_children(); } else { // 0 LOr x = x // lhs is 0, rhs is not node->CopyFrom(*right); } } else if (right->kind() == rgd::Bool) { if (right->boolvalue() == 1) { // x LOr 1 = 1 node->set_kind(rgd::Bool); node->set_boolvalue(1); node->clear_children(); } else { // x LOr 0 = x // rhs is 0, lhs is not node->CopyFrom(*left); } } else { // both sides are symbolic node->set_kind(rgd::LOr); } } } else if (info->op == __dfsan::Xor) { DEBUGF("simplify lxor: %d LXOr %d, %d\n", info->l1, info->l2, info->size); if (unlikely(node->children_size() == 0)) { WARNF("child node size == 0\n"); return INVALID_NODE; } if (unlikely(info->size != 1)) { WARNF("info size != 1\n"); return INVALID_NODE; } uint32_t child = 0; rgd::AstNode *left = nullptr; rgd::AstNode *right = nullptr; if (nested_cmp_cache[info->l1] > 0) { left = node->mutable_children(0); child = 1; // if left child exists, rhs will be child 1 } if (nested_cmp_cache[info->l2] > 0) { right = node->mutable_children(child); } node->set_bits(1); if (likely(info->l1 == 0)) { // lhs is a constant if (unlikely(right == nullptr)) { WARNF("right child is null\n"); return INVALID_NODE; } if (unlikely(right->kind() == rgd::Bool)) { // rhs is a constant node->set_kind(rgd::Bool); node->set_boolvalue(right->boolvalue() ^ (uint32_t)info->op1.i); node->clear_children(); } else { // rhs is symbolic if (info->op1.i == 1) { // 1 LXor x = LNot x node->set_kind(rgd::LNot); } else { // 0 LXor x = x node->CopyFrom(*right); } } } else { if (unlikely(left == nullptr)) { WARNF("left child is null\n"); return INVALID_NODE; } if (unlikely(right == nullptr)) { WARNF("right child is null\n"); return INVALID_NODE; } // check for constant if (unlikely(left->kind() == rgd::Bool)) { if (unlikely(right->kind() == rgd::Bool)) { // both lhs and rhs are constants node->set_kind(rgd::Bool); node->set_boolvalue(right->boolvalue() ^ left->boolvalue()); node->clear_children(); } else if (left->boolvalue() == 0) { // 0 LXor x = x node->CopyFrom(*right); } else { // 1 LXor x = LNot x node->set_kind(rgd::LNot); } } else if (unlikely(right->kind() == rgd::Bool)) { // rhs is constant, lhs is not if (right->boolvalue() == 0) { // x LXor 0 = x node->CopyFrom(*left); } else { // x LXor 1 = LNot x node->set_kind(rgd::LNot); } } else { // both sides are symbolic node->set_kind(rgd::Xor); } } } else if ((info->op & 0xff) == __dfsan::ICmp) { // cmp node node->set_bits(1); if (likely(node->children_size() == 0)) { // if the node has no children, it's a leaf node // check size, concretize if too large auto size = ast_size_cache.at(curr); // load previous value as previous concretization could have // changed the ast size used for allocation auto itr = concretize_node.find(curr); uint8_t concretize = (itr != concretize_node.end() ? itr->second : 0); if (size > max_ast_size_) { DEBUGF("AST size too large: %d = %u\n", curr, size); auto left_size = ast_size_cache.at(info->l1); auto right_size = ast_size_cache.at(info->l2); if (left_size > max_ast_size_) { // concretize left concretize |= 1; // update new size size -= (left_size - 1); } if (right_size > max_ast_size_) { // concretize right concretize |= 2; // update new size size -= (right_size - 1); } DEBUGF("new size: %d = %u\n", curr, size); ast_size_cache[curr] = size; concretize_node[curr] = concretize; } // check for concrete ops uint8_t concrete_ops = concretize; concrete_ops |= info->l1 == 0 ? 1 : 0; concrete_ops |= info->l2 == 0 ? 2 : 0; if (concrete_ops == 3) { // well, both sides have been concretized, simplify the node node->set_kind(rgd::Bool); node->set_boolvalue(eval_icmp(info->op, info->op1.i, info->op2.i)); } else { auto itr = OP_MAP.find(info->op); if (unlikely(itr == OP_MAP.end())) { WARNF("invalid icmp op: %d\n", info->op); return INVALID_NODE; } node->set_kind(itr->second.first); node->set_label(curr); #ifdef DEBUG subroots.insert(curr); #endif } } else if (node->children_size() == 1) { // one side has another icmp, must be simplifiable if (!is_rel_cmp(info->op, __dfsan::bveq) && !is_rel_cmp(info->op, __dfsan::bvneq)) { WARNF("unexpected icmp: %d\n", info->op); // unexpected icmp, set as a constant boolean node->set_kind(rgd::Bool); node->set_boolvalue(eval_icmp(info->op, info->op1.i, info->op2.i)); } else { if (nested_cmp_cache[info->l1]) { // nested icmp in the lhs rgd::AstNode *left = node->mutable_children(0); if (unlikely(left->bits() != 1)) { WARNF("nested icmp lhs bits != 1\n"); return INVALID_NODE; } if (likely(info->l2 == 0)) { if (is_rel_cmp(info->op, __dfsan::bveq)) { if (info->op2.i == 1) { // checking bool == true node->CopyFrom(*left); } else { // checking bool == false node->set_kind(rgd::LNot); } } else { // bvneq if (info->op2.i == 0) { // checking bool != false node->CopyFrom(*left); } else { // checking bool != true node->set_kind(rgd::LNot); } } } else { // l2 != 0, bool icmp bool ?! WARNF("bool icmp bool ?!\n"); node->set_kind(rgd::Bool); node->set_boolvalue(0); node->clear_children(); } } else if (nested_cmp_cache[info->l2] > 0) { // nested icmp in the rhs rgd::AstNode *right = node->mutable_children(0); if (unlikely(right->bits() != 1)) { WARNF("nested icmp rhs bits != 1\n"); return INVALID_NODE; } if (likely(info->l1 == 0)) { if (is_rel_cmp(info->op, __dfsan::bveq)) { if (info->op1.i == 1) { // checking true == bool node->CopyFrom(*right); } else { // checking false == bool node->set_kind(rgd::LNot); } } else { // bvneq if (info->op1.i == 0) { // checking false != bool node->CopyFrom(*right); } else { // checking true != bool node->set_kind(rgd::LNot); } } } else { // l1 != 0, bool icmp bool ?! WARNF("bool icmp bool ?!\n"); node->set_kind(rgd::Bool); node->set_boolvalue(0); node->clear_children(); } } else { WARNF("icmp with child yet no nested icmp?!\n"); return INVALID_NODE; } } } else { // both sides have another icmp, set as a constant boolean node->set_kind(rgd::Bool); node->set_boolvalue(eval_icmp(info->op, info->op1.i, info->op2.i)); node->clear_children(); } } else if (info->op == __dfsan::fmemcmp) { // memcmp is also considered as a root node (relational comparison) if (unlikely(node->children_size() != 0)) { WARNF("memcmp should not have additional icmp"); return INVALID_NODE; } node->set_bits(1); // XXX: treat memcmp as a boolean node->set_kind(rgd::Memcmp); // fix later node->set_label(curr); #ifdef DEBUG subroots.insert(curr); #endif } else { WARNF("Invalid AST node: op = %d\n", info->op); return INVALID_NODE; } // mark as visited and pop from stack visited.insert(curr); prev = curr; stack.pop_back(); node_stack.pop_back(); } } } } catch (std::out_of_range &e) { WARNF("AST %u goes out of range at %s\n", label, e.what()); return INVALID_NODE; } return 0; } [[gnu::hot]] bool RGDAstParser::scan_labels(dfsan_label label) { // assuming label has been checked by caller // assuming the last label scanned is the size of the cache // turns out linear scan is way faster than tree traversal for (size_t i = ast_size_cache.size(); i <= label; i++) { if (i == 0) { // the constant label ast_size_cache.push_back(1); // constant takes one node too branch_to_inputs.emplace_back(input_dep_t(input_size_)); nested_cmp_cache.push_back(0); continue; } dfsan_label_info *info = get_label_info(i); // conservatively check validity of labels // so following parsing will not throw exceptions if (unlikely(info->l1 >= size_ || info->l2 >= size_)) { WARNF("invalid label: %lu, l1=%u, l2=%u\n", i, info->l1, info->l2); return false; } if (info->op == 0) { // AST nodes ast_size_cache.push_back(1); // one Read node // input deps uint32_t input_id = info->op2.i; uint32_t offset = info->op1.i; // skip if invalid if (unlikely(input_id >= inputs_cache.size())) { WARNF("invalid input id: %u\n", input_id); return false; } size_t buf_size = inputs_cache[input_id].second; if (unlikely(offset >= buf_size)) { WARNF("invalid input offset: %u >= %lu\n", offset, buf_size); return false; } branch_to_inputs.emplace_back(input_dep_t(input_size_)); // get flattened index size_t idx = input_to_dep_idx(input_id, offset); auto &itr = branch_to_inputs[i]; itr.set(idx); // flattened location #if DEBUG assert(branch_to_inputs[i].find_first() == idx); #endif // nested cmp? nested_cmp_cache.push_back(0); } else if (info->op == __dfsan::Load) { // AST nodes ast_size_cache.push_back(1); // one Read node // input deps uint32_t input_id = get_label_info(info->l1)->op2.i; uint32_t offset = get_label_info(info->l1)->op1.i; // skip if invalid if (unlikely(input_id >= inputs_cache.size())) { WARNF("invalid input id: %u\n", input_id); return false; } size_t buf_size = inputs_cache[input_id].second; if (unlikely(offset + info->l2 > buf_size)) { WARNF("invalid input offset: %u + %u > %lu\n", offset, info->l2, buf_size); return false; } branch_to_inputs.emplace_back(input_dep_t(input_size_)); // get flattened index size_t idx = input_to_dep_idx(input_id, offset); auto &itr = branch_to_inputs[i]; for (size_t n = 0; n < info->l2; ++n) { // DEBUGF("adding input: %lu <- %lu\n", i, offset + n); itr.set(idx + n); // input offsets } #if DEBUG if (likely(info->l2 > 0)) assert(branch_to_inputs[i].find_first() == idx); #endif // nested cmp? nested_cmp_cache.push_back(0); } else { // AST nodes uint32_t left = info->l1 == 0 ? 1 : ast_size_cache[info->l1]; uint32_t right = info->l2 == 0 ? 1 : ast_size_cache[info->l2]; ast_size_cache.push_back(left + right + 1); // input deps branch_to_inputs.emplace_back(input_dep_t(input_size_)); auto &itr = branch_to_inputs[i]; if (info->l1 != 0) itr |= branch_to_inputs[info->l1]; if (info->l2 != 0) itr |= branch_to_inputs[info->l2]; // nested cmp? uint8_t nested = 0; nested += info->l1 == 0 ? 0 : nested_cmp_cache[info->l1]; nested += info->l2 == 0 ? 0 : nested_cmp_cache[info->l2]; if (info->op == __dfsan::fmemcmp || (info->op & 0xff) == __dfsan::ICmp) nested += 1; nested_cmp_cache.push_back(nested); } } #if DEBUG DEBUGF("ast_size: %d = %u\n", label, ast_size_cache[label]); DEBUGF("input deps %d:", label); auto &itr = branch_to_inputs[label]; for (auto i = itr.find_first(); i != input_dep_t::npos; i = itr.find_next(i)) { DEBUGF("%lu ", i); } DEBUGF("\n"); DEBUGF("nested cmp: %d = %d\n", label, nested_cmp_cache[label]); #endif return true; } RGDAstParser::expr_t RGDAstParser::get_root_expr(dfsan_label label) { if (label < CONST_OFFSET || label == __dfsan::kInitializingLabel || label >= size_) { return nullptr; } expr_t root = nullptr; auto itr = root_expr_cache.find(label); if (itr != root_expr_cache.end()) { root = itr->second; } else { // update ast_size and branch_to_inputs caches if (!scan_labels(label)) { return nullptr; } root = std::make_shared(); std::unordered_set subroots; // we start by constructing a boolean formula with relational expressions // as leaf nodes if (find_roots(label, root.get(), subroots) != 0) { return nullptr; } root_expr_cache.insert({label, root}); #if DEBUG for (auto const& subroot : subroots) { DEBUGF("subroot: %d\n", subroot); } #endif } #if DEBUG printAst(stderr, root.get(), 0); #endif return root; } [[gnu::hot]] int RGDAstParser::to_nnf(bool expected_r, rgd::AstNode *node) { int ret = 0; if (!expected_r) { // we're looking for a negated formula if (node->kind() == rgd::LNot) { // double negation if (unlikely(node->children_size() != 1)) { WARNF("LNot expect a singple child\n"); return INVALID_NODE; } rgd::AstNode *child = node->mutable_children(0); // transform the child, now looking for a true formula ret = to_nnf(true, child); if (unlikely(ret != 0)) { return ret; } node->CopyFrom(*child); } else if (node->kind() == rgd::LAnd) { // De Morgan's law if (unlikely(node->children_size() != 2)) { WARNF("LAnd expect two children\n"); return INVALID_NODE; } node->set_kind(rgd::LOr); ret = to_nnf(false, node->mutable_children(0)); if (unlikely(ret != 0)) { return ret; } ret = to_nnf(false, node->mutable_children(1)); if (unlikely(ret != 0)) { return ret; } } else if (node->kind() == rgd::LOr) { // De Morgan's law if (unlikely(node->children_size() != 2)) { WARNF("LOr expect two children\n"); return INVALID_NODE; } node->set_kind(rgd::LAnd); ret = to_nnf(false, node->mutable_children(0)); if (unlikely(ret != 0)) { return ret; } ret = to_nnf(false, node->mutable_children(1)); if (unlikely(ret != 0)) { return ret; } } else { // leaf node if (rgd::isRelationalKind(node->kind())) { node->set_kind(rgd::negate_cmp(node->kind())); } else if (node->kind() == rgd::Memcmp) { // memcmp is also considered as a leaf node (relational comparison) // memcmp == 0 actually means s1 == s2 // so we don't need to negate it } else { WARNF("Unexpected node kind %d\n", node->kind()); return INVALID_NODE; } } } else { // we're looking for a true formula if (node->kind() == rgd::LNot) { if (unlikely(node->children_size() != 1)) { WARNF("LNot expect a singple child\n"); return INVALID_NODE; } rgd::AstNode *child = node->mutable_children(0); // negate the child, now looking for a false formula ret = to_nnf(false, child); if (unlikely(ret != 0)) { return ret; } node->CopyFrom(*child); } else if (node->kind() == rgd::Memcmp) { // memcmp is also considered as a leaf node (relational comparison) // memcmp == 1 actually means s1 != s2 // so we negate it node->set_kind(rgd::MemcmpN); } else { for (int i = 0; i < node->children_size(); i++) { ret = to_nnf(expected_r, node->mutable_children(i)); if (unlikely(ret != 0)) { return ret; } } } } return 0; } [[gnu::hot]] void RGDAstParser::to_dnf(const rgd::AstNode *node, formula_t &formula) { if (node->kind() == rgd::LAnd) { formula_t left, right; to_dnf(&node->children(0), left); to_dnf(&node->children(1), right); for (auto const& sub1: left) { for (auto const& sub2: right) { clause_t clause; clause.insert(clause.end(), sub1.begin(), sub1.end()); clause.insert(clause.end(), sub2.begin(), sub2.end()); formula.push_back(clause); } } if (left.size() == 0) { formula = right; } } else if (node->kind() == rgd::LOr) { // copy the clauses from the children to_dnf(&node->children(0), formula); to_dnf(&node->children(1), formula); } else { clause_t clause; clause.push_back(node); formula.push_back(clause); } } int RGDAstParser::parse_cond(dfsan_label label, bool result, bool add_nested, std::vector &tasks) { // given a condition, we want to parse them into a DNF form of // relational sub-expressions, where each sub-expression only contains // one relational operator at the root expr_t orig_root = get_root_expr(label); if (orig_root == nullptr) { WARNF("failed to get root expr for label %u\n", label); return -1; } else if (orig_root->kind() == rgd::Bool) { // if the simplified formula is a boolean constant, nothing to do DEBUGF("cond simplified to be a constant\n"); return 0; } // duplication the original root for transformation expr_t root = std::make_shared(); root->CopyFrom(*orig_root); // next, convert the formula to NNF form, possibly negate the root // if we are looking for a false formula bool target_direction = !result; if (to_nnf(target_direction, root.get()) != 0) { WARNF("failed to convert to NNF\n"); return -1; } #if DEBUG printAst(stderr, root.get(), 0); #endif // then we need to convert the boolean formula into a DNF form formula_t dnf; to_dnf(root.get(), dnf); // finally, we construct a search task for each clause in the DNF for (auto const& clause : dnf) { task_t task = construct_task(clause); if (task != nullptr) { tasks.push_back(save_task(task)); } else { WARNF("failed to construct task for clause\n"); continue; // skip the nested task if the current task is invalid } if (solve_nested_) { // collect dependencies based on data-flow (i.e., shared input bytes) clause_t nested_caluse; std::unordered_set inserted; // first, copy the last branch constraints nested_caluse.insert(nested_caluse.end(), clause.begin(), clause.end()); for (auto const& var : clause) inserted.insert(var->label()); bool has_nested = false; // then, iterate each var in the clause for (auto const& var: clause) { const dfsan_label l = var->label(); // assert(branch_to_inputs.size() > l); auto &itr = branch_to_inputs[l]; auto citr = concretize_node.find(l); if (unlikely(citr != concretize_node.end())) { // skip dependencies if the operand is concretized if (citr->second == 1) { // if the lhs is concretized, use the rhs deps only itr = branch_to_inputs[get_label_info(l)->l2]; } else if (citr->second == 2) { // if the rhs is concretized, use the lhs deps only itr = branch_to_inputs[get_label_info(l)->l1]; } } if (unlikely(itr.find_first() == input_dep_t::npos)) { // not actual input dependency, skip continue; } // for each input byte used in the var, we collect additional constraints // first, we use union find to add additional related input bytes std::unordered_set related_inputs; for (auto input = itr.find_first(); input != input_dep_t::npos; input = itr.find_next(input)) { data_flow_deps.get_set(input, related_inputs); // FIXME: should be fine? } // then, we collect the branch constraints for each related input byte for (auto input: related_inputs) { auto const& bucket = input_to_branches[input]; for (auto const& nc : bucket) { if (inserted.count(nc->label())) continue; inserted.insert(nc->label()); has_nested = true; #if DEBUG fprintf(stderr, "add nested constraint: (%d, %d)\n", nc->label(), nc->kind()); #endif nested_caluse.push_back(nc.get()); // XXX: borrow the raw ptr, should be fine? } } } if (has_nested) { // only add nested task if there are additional constraints task_t nested_task = construct_task(nested_caluse); if (nested_task != nullptr) { nested_task->base_task = task; tasks.push_back(save_task(nested_task)); } } } } if (solve_nested_ && add_nested) { save_constraint(orig_root, result); } return 0; } bool RGDAstParser::save_constraint(expr_t expr, bool result) { // assumes scan_labels has been called // make a copy of the expr, just in case expr_t root = std::make_shared(); root->CopyFrom(*expr); // first, convert the formula to NNF form, possibly negate the root // if we are looking for a false formula if (to_nnf(result, root.get()) != 0) { return false; } #if DEBUG printAst(stderr, root.get(), 0); #endif // then we need to convert the boolean formula into a DNF form // NOTE: all ptrs in the formula are raw ptrs *temporarily* // burrowed from the root expr, they will be gone after return formula_t dnf; to_dnf(root.get(), dnf); // now we associate the constraints with input bytes for (auto const& clause : dnf) { // each clause is a conjunction of relational expressions // that need to be evaluated to true (satisfied) // we associate that with the corresponding input bytes for (auto const& var : clause) { // copy the node, as the original node will be gone after return expr_t node = std::make_shared(); node->CopyFrom(*var); // get the input bytes const dfsan_label l = node->label(); #if DEBUG assert(branch_to_inputs.size() > l); #endif auto &itr = branch_to_inputs[l]; auto citr = concretize_node.find(l); if (unlikely(citr != concretize_node.end())) { if (citr->second == 1) { // if the lhs is concretized, use the rhs deps only itr = branch_to_inputs[get_label_info(l)->l2]; } else if (citr->second == 2) { // if the rhs is concretized, use the lhs deps only itr = branch_to_inputs[get_label_info(l)->l1]; } } auto root = itr.find_first(); if (root == input_dep_t::npos) { // not actual input dependency, skip // this can happen for atoi continue; } // update uion find for (auto input = itr.find_next(root); input != input_dep_t::npos; input = itr.find_next(input)) { #if DEBUG DEBUGF("union input bytes: (%zu, %zu)\n", root, input); #endif root = data_flow_deps.merge(root, input); if (unlikely(root == rgd::UnionFind::INVALID)) { WARNF("invalid input to union find\n"); return false; } } // add the constraint auto &bucket = input_to_branches[root]; bucket.push_back(node); // we need to record the kind as it may be negated during transformation #if DEBUG DEBUGF("add df constraint: %zu <- (%d, %d)\n", root, l, node->kind()); #endif } } return true; } void RGDAstParser::add_nested_constraint(task_t task, const clause_t &nested_caluse) { for (auto const& node: nested_caluse) { // check cache, should happen most of the time auto itr = constraint_cache.find(node->label()); if (likely(itr != constraint_cache.end())) { task->add_constraint(itr->second, node->kind()); continue; } // otherwise, parse the AST into a constraint constraint_t constraint = parse_constraint(node->label()); if (likely(constraint != nullptr)) { task->add_constraint(constraint, node->kind()); constraint_cache.insert({node->label(), constraint}); } } } int RGDAstParser::parse_gep(dfsan_label ptr_label, uptr ptr, dfsan_label index_label, int64_t index, uint64_t num_elems, uint64_t elem_size, int64_t current_offset, bool enum_index, std::vector &tasks) { // check validity of the labels if (index_label < CONST_OFFSET || index_label == __dfsan::kInitializingLabel || index_label >= size_) { return -1; } // update ast_size and branch_to_inputs caches // if the index_label has been scanned before, it won't be scanned again if (!scan_labels(index_label)) { return -1; } // sanity checks if (unlikely(ast_size_cache.size() <= index_label)) { WARNF("invalid label %u, larger than ast_size_cache: %lu\n", index_label, ast_size_cache.size()); return -1; } if (unlikely(nested_cmp_cache.at(index_label) > 0)) { WARNF("unexpected nested cmp in parse_gep for %u, skip\n", index_label); return -1; } auto ast_size = ast_size_cache.at(index_label); if (unlikely(ast_size == 0)) { WARNF("invalid label %u, ast_size_cache is 0\n", index_label); return 0; } else if (unlikely(ast_size > max_ast_size_)) { DEBUGF("skip large AST (%lu) in parse_gep for %u\n", ast_size, index_label); return 0; // not an error, just skip } // early return if nothing to do if (!enum_index || // if we are not enumerating the index (num_elems == 0 && // if the GEP type is not an array, // and we also don't have a pointer label ptr_label)) { return 0; } // hmm, since the gep constraints we want to solve are not in the union table, // which means parse_constraint will not work, // so we have to construct the tasks directly here // // first, parse the index_label into a partial constraint // again, the index_label is not a cmp node constraint_t partial_constraint = nullptr; // check cache first auto itr = constraint_cache.find(index_label); if (itr != constraint_cache.end()) { partial_constraint = itr->second; } else { // otherwise, parse the AST into a constraint std::unordered_set visited; partial_constraint = std::make_shared(ast_size + 3); // leave extra one buffer? // add the constant node first auto const_node = partial_constraint->ast->add_children(); const_node->set_kind(rgd::Constant); const_node->set_label(0); uint32_t size = get_label_info(index_label)->size; const_node->set_bits(size); // size of the index // map args uint32_t arg_index = 0; // first arg const_node->set_index(arg_index); partial_constraint->input_args.push_back(std::make_pair(false, 0)); // use 0 as a temporary placeholder partial_constraint->const_num += 1; uint32_t hash = rgd::xxhash(size, rgd::Constant, arg_index); const_node->set_hash(hash); // now, parse the index_label auto index_node = partial_constraint->ast->add_children(); try { if (!do_uta_rel(index_label, index_node, partial_constraint, visited)) { WARNF("failed to parse index_label %u\n", index_label); return -1; } } catch (std::bad_alloc &e) { WARNF("failed to allocate memory for gep constraint\n"); return -1; } catch (std::out_of_range &e) { WARNF("AST %u goes out of range at %s\n", index_label, e.what()); return -1; } // setup root cmp node auto cmp_node = partial_constraint->ast.get(); cmp_node->set_kind(rgd::Equal); // a placeholder, not really useful cmp_node->set_label(0); // so jigsaw will not cache it as visited cmp_node->set_bits(1); // again, in jigsaw, we don't care about actual cmp kind hash = rgd::xxhash(const_node->hash(), (rgd::Bool << 16) | 1, index_node->hash()); cmp_node->set_hash(hash); // done parsing, add to cache constraint_cache.insert({index_label, partial_constraint}); } if (unlikely(partial_constraint == nullptr)) { WARNF("failed to parse index_label %u\n", index_label); return -1; } // next, retrive nested constraints if needed clause_t nested_caluse; if (solve_nested_) { auto &itr = branch_to_inputs[index_label]; if (unlikely(itr.find_first() != input_dep_t::npos)) { // use union find to add additional related input bytes std::unordered_set related_inputs; for (auto input = itr.find_first(); input != input_dep_t::npos; input = itr.find_next(input)) { data_flow_deps.get_set(input, related_inputs); // FIXME: should be fine? } // collect the branch constraints for each related input byte std::unordered_set inserted; for (auto input: related_inputs) { auto const& bucket = input_to_branches[input]; for (auto const& nc : bucket) { if (inserted.insert(nc->label()).second) { #if DEBUG fprintf(stderr, "add nested constraint for gep: (%d, %d)\n", nc->label(), nc->kind()); #endif nested_caluse.push_back(nc.get()); // XXX: borrow the raw ptr, should be fine? } } } } } // finally, we are ready to construct GEP tasks // if (enum_index) { // TODO: } // bounds solving are seperated from index enumeration now return 0; } int RGDAstParser::add_constraints(dfsan_label label, uint64_t result) { // offset constraint should be in the form of r = (offset == label) = true if (!solve_nested_) { // only matters in nested mode return 0; } // check validity of the label if (label < CONST_OFFSET || label == __dfsan::kInitializingLabel || label >= size_) { return -1; } // check validity of the result if (result != 1) { WARNF("unexpected result in add_constraints: %lu\n", result); return -1; } expr_t root = nullptr; auto itr = root_expr_cache.find(label); if (itr != root_expr_cache.end()) { // the constraint has already been added, skip return 0; } // update ast_size and branch_to_inputs caches if (!scan_labels(label)) { return -1; } // other sanitity checks // 1. there shouldn't be any nested cmp if (nested_cmp_cache[label] > 0) { WARNF("unexpected nested cmp in add_constraints for %u\n", label); return -1; } dfsan_label_info *info = get_label_info(label); // 2. the label should be a bveq one if (!is_rel_cmp(info->op, __dfsan::bveq)) { WARNF("unexpected cmp op (%d) in add_constraints for %u\n", info->op, label); return -1; } // 3. one operand should be a constant if (info->l1 != 0) { WARNF("unexpected non-constant operand1 (%u) in add_constraints for %u\n", info->l1, label); return -1; } // check for ast size if (ast_size_cache[info->l2] > max_ast_size_) { DEBUGF("skip large AST (%lu) in add_constraints for %u\n", ast_size_cache[label], label); return 0; // not an error, just skip } // setup node root = std::make_shared(1); root->set_bits(1); root->set_kind(rgd::Equal); root->set_label(label); root_expr_cache.insert({label, root}); if (!save_constraint(root, true)) { return -1; } return 0; } ================================================ FILE: python/CMakeLists.txt ================================================ set(CMAKE_POSITION_INDEPENDENT_CODE ON) set(CMAKE_CXX_STANDARD 17) find_package(Python3 COMPONENTS Interpreter Development) if (Python3_Development_FOUND) message(STATUS "Python3_VERSION ${Python3_VERSION}") else() message(FATAL_ERROR "Cannot find Python development!") endif() add_library(pysymsan SHARED symsan-py.cpp) set_target_properties(pysymsan PROPERTIES PREFIX "") set_target_properties(pysymsan PROPERTIES OUTPUT_NAME "symsan") set_target_properties(pysymsan PROPERTIES SUFFIX ".cpython-${Python3_VERSION_MAJOR}${Python3_VERSION_MINOR}-x86_64-linux-gnu.so") target_include_directories(pysymsan PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../runtime ${Python3_INCLUDE_DIRS} ) target_link_libraries(pysymsan PRIVATE launcher z3parser z3 ${Python3_LIBRARIES} rt ) install (TARGETS Fastgen DESTINATION ${SYMSAN_LIB_DIR}) ================================================ FILE: python/README.md ================================================ Provide a python binding to launch symsan-instrumented binary, receive events, parse constraints, and solve constraints. ``` static PyMethodDef SymSanMethods[] = { {"init", SymSanInit, METH_VARARGS, "initialize symsan target"}, {"config", (PyCFunction)SymSanConfig, METH_VARARGS | METH_KEYWORDS, "config symsan"}, {"run", (PyCFunction)SymSanRun, METH_VARARGS | METH_KEYWORDS, "run symsan target, optional stdin=file"}, {"read_event", SymSanReadEvent, METH_VARARGS, "read a symsan event"}, {"terminate", (PyCFunction)SymSanTerminate, METH_NOARGS, "terminate current symsan instance"}, {"destroy", (PyCFunction)SymSanDestroy, METH_NOARGS, "destroy symsan target"}, {"reset_input", InitParser, METH_VARARGS, "reset the symbolic expression parser with a new input"}, {"parse_cond", ParseCond, METH_VARARGS, "parse trace_cond event into solving tasks"}, {"parse_gep", ParseGEP, METH_VARARGS, "parse trace_gep event into solving tasks"}, {"add_constraint", AddConstraint, METH_VARARGS, "add a constraint"}, {"record_memcmp", RecordMemcmp, METH_VARARGS, "record a memcmp event"}, {"solve_task", SolveTask, METH_VARARGS, "solve a task"}, {NULL, NULL, 0, NULL} /* Sentinel */ }; ``` Currently only z3 solver is supported, will merge jigsaw and i2s later. ================================================ FILE: python/symsan-py.cpp ================================================ #include "defs.h" #include "debug.h" #include "version.h" #include "dfsan/dfsan.h" extern "C" { #include "launch.h" } #include "parse-z3.h" #include #include #include #include #include #include #include #include #include #define PY_SSIZE_T_CLEAN #include // z3parser static z3::context __z3_context; symsan::Z3ParserSolver *__z3_parser = nullptr; static PyObject* SymSanInit(PyObject *self, PyObject *args) { const char *program; unsigned long long ut_size = uniontable_size; if (!PyArg_ParseTuple(args, "s|K", &program, &ut_size)) { return NULL; } // setup launcher void *shm_base = symsan_init(program, ut_size); if (shm_base == (void *)-1) { fprintf(stderr, "Failed to map shm: %s\n", strerror(errno)); return PyErr_SetFromErrno(PyExc_OSError); } // setup parser __z3_parser = new symsan::Z3ParserSolver(shm_base, ut_size, __z3_context); if (__z3_parser == nullptr) { fprintf(stderr, "Failed to initialize parser\n"); return PyErr_NoMemory(); } return PyCapsule_New(shm_base, "dfsan_label_info", NULL); } static PyObject* SymSanConfig(PyObject *self, PyObject *args, PyObject *keywds) { static const char *kwlist[] = {"input", "args", "debug", "bounds", "undefined", NULL}; const char *input = NULL; PyObject *iargs = NULL; int debug = 0; int bounds = 0; int solve_ub = 0; if (!PyArg_ParseTupleAndKeywords(args, keywds, "s|O!iii", const_cast(kwlist), &input, &PyList_Type, &iargs, &debug, &bounds, &solve_ub)) { return NULL; } if (input == NULL) { PyErr_SetString(PyExc_ValueError, "missing input"); return NULL; } if (symsan_set_input(input) != 0) { PyErr_SetString(PyExc_ValueError, "invalid input"); return NULL; } if (args != NULL) { Py_ssize_t argc = PyList_Size(iargs); char *argv[argc]; for (Py_ssize_t i = 0; i < argc; i++) { PyObject *item = PyList_GetItem(iargs, i); if (item == NULL) { PyErr_SetString(PyExc_RuntimeError, "failed to retrieve args list"); return NULL; } if (!PyUnicode_Check(item)) { PyErr_SetString(PyExc_TypeError, "args must be a list of strings"); return NULL; } argv[i] = const_cast(PyUnicode_AsUTF8(item)); } if (symsan_set_args(argc, argv) != 0) { PyErr_SetString(PyExc_ValueError, "invalid args"); return NULL; } } if (symsan_set_debug(debug) != 0) { PyErr_SetString(PyExc_ValueError, "invalid debug"); return NULL; } if (symsan_set_bounds_check(bounds) != 0) { PyErr_SetString(PyExc_ValueError, "invalid bounds"); return NULL; } if (symsan_set_solve_ub(solve_ub) != 0) { PyErr_SetString(PyExc_ValueError, "invalid solve_ub"); return NULL; } Py_RETURN_NONE; } static PyObject* SymSanRun(PyObject *self, PyObject *args, PyObject *keywds) { static const char *kwlist[] = {"stdin", NULL}; const char *file = NULL; int fd = 0; if (!PyArg_ParseTupleAndKeywords(args, keywds, "|s", const_cast(kwlist), &file)) { return NULL; } if (file) { fd = open(file, O_RDONLY); if (fd < 0) { PyErr_SetFromErrno(PyExc_OSError); return NULL; } } int ret = symsan_run(fd); if (file) { close(fd); } if (ret < 0) { PyErr_SetString(PyExc_ValueError, "failed to launch target"); return NULL; } Py_RETURN_NONE; } static PyObject* SymSanReadEvent(PyObject *self, PyObject *args) { PyObject *ret; char *buf; Py_ssize_t size; unsigned timeout = 0; if (!PyArg_ParseTuple(args, "n|I", &size, &timeout)) { return NULL; } if (size <= 0) { PyErr_SetString(PyExc_ValueError, "invalid buffer size"); return NULL; } buf = (char *)malloc(size); ssize_t read = symsan_read_event(buf, size, timeout); if (read < 0) { PyErr_SetFromErrno(PyExc_OSError); free(buf); return NULL; } ret = PyBytes_FromStringAndSize(buf, read); free(buf); return ret; } static PyObject* SymSanTerminate(PyObject *self) { if (symsan_terminate() != 0) { PyErr_SetString(PyExc_RuntimeError, "failed to terminate target"); return NULL; } int status, is_killed; is_killed = symsan_get_exit_status(&status); PyObject *ret = PyTuple_New(2); PyTuple_SetItem(ret, 0, PyLong_FromLong(status)); PyTuple_SetItem(ret, 1, PyLong_FromLong(is_killed)); return ret; } static PyObject* SymSanDestroy(PyObject *self) { if (__z3_parser != nullptr) { delete __z3_parser; symsan_destroy(); __z3_parser = nullptr; } Py_RETURN_NONE; } static PyObject* InitParser(PyObject *self, PyObject *args) { if (__z3_parser == nullptr) { PyErr_SetString(PyExc_RuntimeError, "parser not initialized"); return NULL; } std::vector inputs; PyObject *iargs = NULL; if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &iargs)) { return NULL; } Py_ssize_t argc = PyList_Size(iargs); for (Py_ssize_t i = 0; i < argc; i++) { PyObject *item = PyList_GetItem(iargs, i); if (item == NULL) { PyErr_SetString(PyExc_RuntimeError, "failed to retrieve args list"); return NULL; } if (!PyBytes_Check(item)) { PyErr_SetString(PyExc_TypeError, "args must be a list of bytes"); return NULL; } Py_ssize_t size; char *data; if (PyBytes_AsStringAndSize(item, &data, &size) != 0) { // exception should have been set? return NULL; } inputs.push_back({(uint8_t*)data, size}); } if (__z3_parser->restart(inputs) != 0) { PyErr_SetString(PyExc_RuntimeError, "failed to restart parser"); return NULL; } Py_RETURN_NONE; } static PyObject* ParseCond(PyObject *self, PyObject *args) { if (__z3_parser == nullptr) { PyErr_SetString(PyExc_RuntimeError, "parser not initialized"); return NULL; } PyObject *ret; dfsan_label label = 0; uint64_t result = 0; uint16_t flags = 0; if (!PyArg_ParseTuple(args, "IKH", &label, &result, &flags)) { return NULL; } std::vector tasks; if (__z3_parser->parse_cond(label, result, flags & F_ADD_CONS, tasks) != 0) { PyErr_SetString(PyExc_RuntimeError, "failed to parse condition"); return NULL; } ret = PyList_New(tasks.size()); for (size_t i = 0; i < tasks.size(); i++) { PyObject *task = PyLong_FromUnsignedLongLong(tasks[i]); PyList_SetItem(ret, i, task); } return ret; } static PyObject* ParseGEP(PyObject *self, PyObject *args) { if (__z3_parser == nullptr) { PyErr_SetString(PyExc_RuntimeError, "parser not initialized"); return NULL; } PyObject *ret; dfsan_label ptr_label = 0; uptr ptr = 0; dfsan_label index_label = 0; int64_t index = 0; uint64_t num_elems = 0; uint64_t elem_size = 0; int64_t current_offset = 0; bool enum_index = false; // XXX: default to false? if (!PyArg_ParseTuple(args, "IKILKKLp", &ptr_label, &ptr, &index_label, &index, &num_elems, &elem_size, ¤t_offset, &enum_index)) { return NULL; } std::vector tasks; if (__z3_parser->parse_gep(ptr_label, ptr, index_label, index, num_elems, elem_size, current_offset, enum_index, tasks) != 0) { PyErr_SetString(PyExc_RuntimeError, "failed to parse GEP"); return NULL; } ret = PyList_New(tasks.size()); for (size_t i = 0; i < tasks.size(); i++) { PyObject *task = PyLong_FromUnsignedLongLong(tasks[i]); PyList_SetItem(ret, i, task); } return ret; } static PyObject* AddConstraint(PyObject *self, PyObject *args) { if (__z3_parser == nullptr) { PyErr_SetString(PyExc_RuntimeError, "parser not initialized"); return NULL; } dfsan_label label = 0; uint64_t val = 0; if (!PyArg_ParseTuple(args, "IL", &label, &val)) { return NULL; } if (__z3_parser->add_constraints(label, val) != 0) { PyErr_SetString(PyExc_RuntimeError, "failed to add constraint"); return NULL; } Py_RETURN_NONE; } static PyObject* RecordMemcmp(PyObject *self, PyObject *args) { if (__z3_parser == nullptr) { PyErr_SetString(PyExc_RuntimeError, "parser not initialized"); return NULL; } dfsan_label label = 0; PyObject *buf = NULL; if (!PyArg_ParseTuple(args, "IS", &label, &buf)) { return NULL; } Py_ssize_t size; char *data; if (PyBytes_AsStringAndSize(buf, &data, &size) != 0) { // exception should have been set? return NULL; } if (__z3_parser->record_memcmp(label, (uint8_t*)data, size) != 0) { PyErr_SetString(PyExc_RuntimeError, "failed to record memcmp"); return NULL; } Py_RETURN_NONE; } static PyObject* SolveTask(PyObject *self, PyObject *args) { if (__z3_parser == nullptr) { PyErr_SetString(PyExc_RuntimeError, "parser not initialized"); return NULL; } uint64_t id = 0; unsigned timeout = 5000; if (!PyArg_ParseTuple(args, "K|I", &id, &timeout)) { return NULL; } symsan::Z3ParserSolver::solution_t solutions; int status = __z3_parser->solve_task(id, timeout, solutions); PyObject *sols = PyList_New(solutions.size()); for (size_t i = 0; i < solutions.size(); i++) { PyObject *sol = PyTuple_New(3); auto val = solutions[i]; PyTuple_SetItem(sol, 0, PyLong_FromUnsignedLong(val.id)); PyTuple_SetItem(sol, 1, PyLong_FromUnsignedLong(val.offset)); PyTuple_SetItem(sol, 2, PyLong_FromUnsignedLong(val.val)); PyList_SetItem(sols, i, sol); } PyObject *ret = PyTuple_New(2); PyTuple_SetItem(ret, 0, PyLong_FromLong(status)); PyTuple_SetItem(ret, 1, sols); return ret; } static PyMethodDef SymSanMethods[] = { {"init", SymSanInit, METH_VARARGS, "initialize symsan target"}, {"config", (PyCFunction)SymSanConfig, METH_VARARGS | METH_KEYWORDS, "config symsan"}, {"run", (PyCFunction)SymSanRun, METH_VARARGS | METH_KEYWORDS, "run symsan target, optional stdin=file"}, {"read_event", SymSanReadEvent, METH_VARARGS, "read a symsan event"}, {"terminate", (PyCFunction)SymSanTerminate, METH_NOARGS, "terminate current symsan instance"}, {"destroy", (PyCFunction)SymSanDestroy, METH_NOARGS, "destroy symsan target"}, {"reset_input", InitParser, METH_VARARGS, "reset the symbolic expression parser with a new input"}, {"parse_cond", ParseCond, METH_VARARGS, "parse trace_cond event into solving tasks"}, {"parse_gep", ParseGEP, METH_VARARGS, "parse trace_gep event into solving tasks"}, {"add_constraint", AddConstraint, METH_VARARGS, "add a constraint"}, {"record_memcmp", RecordMemcmp, METH_VARARGS, "record a memcmp event"}, {"solve_task", SolveTask, METH_VARARGS, "solve a task"}, {NULL, NULL, 0, NULL} /* Sentinel */ }; static char SymSanDoc[] = "Python3 wrapper over SymSan launch, parser, and solver."; static PyModuleDef SymSanModule = { PyModuleDef_HEAD_INIT, "symsan", /* name of module */ SymSanDoc, /* module documentation, may be NULL */ -1, /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */ SymSanMethods }; PyMODINIT_FUNC PyInit_symsan(void) { // check if initialized before? if (__z3_parser != nullptr) { delete __z3_parser; symsan_destroy(); } return PyModule_Create(&SymSanModule); } ================================================ FILE: python/test.py ================================================ import sys import ctypes import symsan class pipe_msg(ctypes.Structure): _pack_ = 1 _fields_ = [("type", ctypes.c_uint16), ("flags", ctypes.c_uint16), ("instance_id", ctypes.c_uint32), ("addr", ctypes.c_ulonglong), ("context", ctypes.c_uint32), ("id", ctypes.c_uint32), ("label", ctypes.c_uint32), ("result", ctypes.c_uint64)] class memcmp_msg(ctypes.Structure): _pack_ = 1 _fields_ = [("label", ctypes.c_uint32)] content = bytes() prog = sys.argv[1] file = sys.argv[2] symsan.init(sys.argv[1]) symsan.config(file, args=[prog, file], debug=1, bounds=0) symsan.run() f = open(file, "rb") buf = f.read() symsan.reset_input([buf]) while True: e = symsan.read_event(ctypes.sizeof(pipe_msg)) if len(e) < ctypes.sizeof(pipe_msg): break msg = pipe_msg.from_buffer_copy(e) print(f"received msg: type={msg.type}, flags={msg.flags}, " f"addr={msg.addr:x}, context={msg.context}, cid={msg.id}, " f"label={msg.label}, result={msg.result}") tasks = [] if msg.type == 0: tasks = symsan.parse_cond(msg.label, msg.result, msg.flags) print(tasks) elif msg.type == 2 and msg.flags == 1: label = msg.label size = msg.result m = symsan.read_event(ctypes.sizeof(memcmp_msg) + size) if len(m) < ctypes.sizeof(memcmp_msg) + size: print("error reading memcmp msg") break buf = memcmp_msg.from_buffer_copy(m) if buf.label != label: print("error reading memcmp msg") break buf.content = m[ctypes.sizeof(memcmp_msg):] print(f"memcmp content: {buf.content.hex()}") symsan.record_memcmp(label, buf.content) for task in tasks: r, sol = symsan.solve_task(task) print(sol) status, is_killed = symsan.terminate() print(f"exit status {status}, killed? {is_killed}") symsan.destroy() ================================================ FILE: runtime/CMakeLists.txt ================================================ # Add path for custom compiler-rt modules. list(INSERT CMAKE_MODULE_PATH 0 "${CMAKE_CURRENT_SOURCE_DIR}/cmake") set(COMPILER_RT_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE PATH "Path where built compiler-rt libraries should be stored.") set(COMPILER_RT_EXEC_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/bin CACHE PATH "Path where built compiler-rt executables should be stored.") set(COMPILER_RT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") set(COMPILER_RT_INSTALL_PATH ${CMAKE_INSTALL_PREFIX} CACHE PATH "Path where built compiler-rt libraries should be installed.") set(COMPILER_RT_LIBRARY_OUTPUT_DIR ${COMPILER_RT_OUTPUT_DIR}) set(COMPILER_RT_LIBRARY_INSTALL_DIR ${SYMSAN_LIB_DIR}) set(ARM64 aarch64) set(X86_64 x86_64) set(MIPS64 mips64 mips64el) if(APPLE) set(ARM64 arm64) set(X86_64 x86_64 x86_64h) endif() set(CAN_TARGET_${X86_64} 1) set(DFSAN_SUPPORTED_ARCH ${X86_64}) # ${MIPS64} ${ARM64} set(SANITIZER_COMMON_SUPPORTED_ARCH ${X86_64}) # ${MIPS64} ${ARM64} list(APPEND SANITIZER_COMMON_CFLAGS "-stdlib=libc++") list(APPEND SANITIZER_COMMON_CFLAGS -O3) list(APPEND SANITIZER_COMMON_CFLAGS -g) list(APPEND SANITIZER_COMMON_CFLAGS -fPIC) include(CheckIncludeFile) check_include_file(rpc/xdr.h HAVE_RPC_XDR_H) if (NOT HAVE_RPC_XDR_H) set(HAVE_RPC_XDR_H 0) endif() add_custom_target(compiler-rt ALL) add_custom_target(install-compiler-rt) add_custom_target(install-compiler-rt-stripped) set_property( TARGET compiler-rt install-compiler-rt install-compiler-rt-stripped PROPERTY FOLDER "Compiler-RT Misc" ) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) include(AddCompilerRT) include(SanitizerUtils) set(CMAKE_CXX_STANDARD 14) add_subdirectory(sanitizer_common) add_subdirectory(interception) add_subdirectory(dfsan) ================================================ FILE: runtime/cmake/AddCompilerRT.cmake ================================================ include(ExternalProject) include(CompilerRTUtils) function(set_target_output_directories target output_dir) # For RUNTIME_OUTPUT_DIRECTORY variable, Multi-configuration generators # append a per-configuration subdirectory to the specified directory. # To avoid the appended folder, the configuration specific variable must be # set 'RUNTIME_OUTPUT_DIRECTORY_${CONF}': # RUNTIME_OUTPUT_DIRECTORY_DEBUG, RUNTIME_OUTPUT_DIRECTORY_RELEASE, ... if(CMAKE_CONFIGURATION_TYPES) foreach(build_mode ${CMAKE_CONFIGURATION_TYPES}) string(TOUPPER "${build_mode}" CONFIG_SUFFIX) set_target_properties("${target}" PROPERTIES "ARCHIVE_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${output_dir} "LIBRARY_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${output_dir} "RUNTIME_OUTPUT_DIRECTORY_${CONFIG_SUFFIX}" ${output_dir}) endforeach() else() set_target_properties("${target}" PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${output_dir} LIBRARY_OUTPUT_DIRECTORY ${output_dir} RUNTIME_OUTPUT_DIRECTORY ${output_dir}) endif() endfunction() # Tries to add an "object library" target for a given list of OSs and/or # architectures with name "." for non-Darwin platforms if # architecture can be targeted, and "." for Darwin platforms. # add_compiler_rt_object_libraries( # OS # ARCHS # SOURCES # CFLAGS # DEFS # DEPS # ADDITIONAL_HEADERS
) function(add_compiler_rt_object_libraries name) cmake_parse_arguments(LIB "" "" "OS;ARCHS;SOURCES;CFLAGS;DEFS;DEPS;ADDITIONAL_HEADERS" ${ARGN}) set(libnames) if(APPLE) foreach(os ${LIB_OS}) set(libname "${name}.${os}") set(libnames ${libnames} ${libname}) set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS}) list_intersect(LIB_ARCHS_${libname} DARWIN_${os}_ARCHS LIB_ARCHS) endforeach() else() foreach(arch ${LIB_ARCHS}) set(libname "${name}.${arch}") set(libnames ${libnames} ${libname}) set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS}) if(NOT CAN_TARGET_${arch}) message(FATAL_ERROR "Architecture ${arch} can't be targeted") return() endif() endforeach() endif() foreach(libname ${libnames}) add_library(${libname} OBJECT ${LIB_SOURCES}) if(LIB_DEPS) add_dependencies(${libname} ${LIB_DEPS}) endif() # Strip out -msse3 if this isn't macOS. set(target_flags ${LIB_CFLAGS}) if(APPLE AND NOT "${libname}" MATCHES ".*\.osx.*") list(REMOVE_ITEM target_flags "-msse3") endif() set_target_compile_flags(${libname} ${CMAKE_CXX_FLAGS} ${extra_cflags_${libname}} ${target_flags}) set_property(TARGET ${libname} APPEND PROPERTY COMPILE_DEFINITIONS ${LIB_DEFS}) set_target_properties(${libname} PROPERTIES FOLDER "Compiler-RT Libraries") if(APPLE) set_target_properties(${libname} PROPERTIES OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}") endif() endforeach() endfunction() # Takes a list of object library targets, and a suffix and appends the proper # TARGET_OBJECTS string to the output variable. # format_object_libs( ...) macro(format_object_libs output suffix) foreach(lib ${ARGN}) list(APPEND ${output} $) endforeach() endmacro() function(add_compiler_rt_component name) add_custom_target(${name}) set_target_properties(${name} PROPERTIES FOLDER "Compiler-RT Misc") if(COMMAND runtime_register_component) runtime_register_component(${name}) endif() add_dependencies(compiler-rt ${name}) endfunction() function(add_asm_sources output) set(${output} ${ARGN} PARENT_SCOPE) # Xcode will try to compile asm files as C ('clang -x c'), and that will fail. if (${CMAKE_GENERATOR} STREQUAL "Xcode") enable_language(ASM) else() # Pass ASM file directly to the C++ compiler. set_source_files_properties(${ARGN} PROPERTIES LANGUAGE C) endif() endfunction() macro(set_output_name output name arch) if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR) set(${output} ${name}) else() if(ANDROID AND ${arch} STREQUAL "i386") set(${output} "${name}-i686${COMPILER_RT_OS_SUFFIX}") else() set(${output} "${name}-${arch}${COMPILER_RT_OS_SUFFIX}") endif() endif() endmacro() # Adds static or shared runtime for a list of architectures and operating # systems and puts it in the proper directory in the build and install trees. # add_compiler_rt_runtime( # {STATIC|SHARED} # ARCHS # OS # SOURCES # CFLAGS # LINK_FLAGS # DEFS # LINK_LIBS (only for shared library) # OBJECT_LIBS # PARENT_TARGET # ADDITIONAL_HEADERS
) function(add_compiler_rt_runtime name type) if(NOT type MATCHES "^(STATIC|SHARED)$") message(FATAL_ERROR "type argument must be STATIC or SHARED") return() endif() cmake_parse_arguments(LIB "" "PARENT_TARGET" "OS;ARCHS;SOURCES;CFLAGS;LINK_FLAGS;DEFS;LINK_LIBS;OBJECT_LIBS;ADDITIONAL_HEADERS" ${ARGN}) set(libnames) # Until we support this some other way, build compiler-rt runtime without LTO # to allow non-LTO projects to link with it. if(COMPILER_RT_HAS_FNO_LTO_FLAG) set(NO_LTO_FLAGS "-fno-lto") else() set(NO_LTO_FLAGS "") endif() if(APPLE) foreach(os ${LIB_OS}) # Strip out -msse3 if this isn't macOS. list(LENGTH LIB_CFLAGS HAS_EXTRA_CFLAGS) if(HAS_EXTRA_CFLAGS AND NOT "${os}" MATCHES "^(osx)$") list(REMOVE_ITEM LIB_CFLAGS "-msse3") endif() if(type STREQUAL "STATIC") set(libname "${name}_${os}") else() set(libname "${name}_${os}_dynamic") set(extra_link_flags_${libname} ${DARWIN_${os}_LINK_FLAGS} ${LIB_LINK_FLAGS}) endif() list_intersect(LIB_ARCHS_${libname} DARWIN_${os}_ARCHS LIB_ARCHS) if(LIB_ARCHS_${libname}) list(APPEND libnames ${libname}) set(extra_cflags_${libname} ${DARWIN_${os}_CFLAGS} ${NO_LTO_FLAGS} ${LIB_CFLAGS}) set(output_name_${libname} ${libname}${COMPILER_RT_OS_SUFFIX}) set(sources_${libname} ${LIB_SOURCES}) format_object_libs(sources_${libname} ${os} ${LIB_OBJECT_LIBS}) get_compiler_rt_output_dir(${COMPILER_RT_DEFAULT_TARGET_ARCH} output_dir_${libname}) get_compiler_rt_install_dir(${COMPILER_RT_DEFAULT_TARGET_ARCH} install_dir_${libname}) endif() endforeach() else() foreach(arch ${LIB_ARCHS}) if(NOT CAN_TARGET_${arch}) message(FATAL_ERROR "Architecture ${arch} can't be targeted") return() endif() if(type STREQUAL "STATIC") set(libname "${name}-${arch}") set_output_name(output_name_${libname} ${name} ${arch}) else() set(libname "${name}-dynamic-${arch}") set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS} ${LIB_CFLAGS}) set(extra_link_flags_${libname} ${TARGET_${arch}_LINK_FLAGS} ${LIB_LINK_FLAGS}) if(WIN32) set_output_name(output_name_${libname} ${name}_dynamic ${arch}) else() set_output_name(output_name_${libname} ${name} ${arch}) endif() endif() set(sources_${libname} ${LIB_SOURCES}) format_object_libs(sources_${libname} ${arch} ${LIB_OBJECT_LIBS}) set(libnames ${libnames} ${libname}) set(extra_cflags_${libname} ${TARGET_${arch}_CFLAGS} ${NO_LTO_FLAGS} ${LIB_CFLAGS}) get_compiler_rt_output_dir(${arch} output_dir_${libname}) get_compiler_rt_install_dir(${arch} install_dir_${libname}) endforeach() endif() if(NOT libnames) return() endif() if(LIB_PARENT_TARGET) # If the parent targets aren't created we should create them if(NOT TARGET ${LIB_PARENT_TARGET}) add_custom_target(${LIB_PARENT_TARGET}) set_target_properties(${LIB_PARENT_TARGET} PROPERTIES FOLDER "Compiler-RT Misc") endif() if(NOT TARGET install-${LIB_PARENT_TARGET}) # The parent install target specifies the parent component to scrape up # anything not installed by the individual install targets, and to handle # installation when running the multi-configuration generators. add_custom_target(install-${LIB_PARENT_TARGET} DEPENDS ${LIB_PARENT_TARGET} COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=${LIB_PARENT_TARGET} -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") add_custom_target(install-${LIB_PARENT_TARGET}-stripped DEPENDS ${LIB_PARENT_TARGET} COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=${LIB_PARENT_TARGET} -DCMAKE_INSTALL_DO_STRIP=1 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") set_target_properties(install-${LIB_PARENT_TARGET} PROPERTIES FOLDER "Compiler-RT Misc") set_target_properties(install-${LIB_PARENT_TARGET}-stripped PROPERTIES FOLDER "Compiler-RT Misc") add_dependencies(install-compiler-rt install-${LIB_PARENT_TARGET}) add_dependencies(install-compiler-rt-stripped install-${LIB_PARENT_TARGET}-stripped) endif() endif() foreach(libname ${libnames}) # If you are using a multi-configuration generator we don't generate # per-library install rules, so we fall back to the parent target COMPONENT if(CMAKE_CONFIGURATION_TYPES AND LIB_PARENT_TARGET) set(COMPONENT_OPTION COMPONENT ${LIB_PARENT_TARGET}) else() set(COMPONENT_OPTION COMPONENT ${libname}) endif() add_library(${libname} ${type} ${sources_${libname}}) set_target_compile_flags(${libname} ${extra_cflags_${libname}}) set_target_link_flags(${libname} ${extra_link_flags_${libname}}) set_property(TARGET ${libname} APPEND PROPERTY COMPILE_DEFINITIONS ${LIB_DEFS}) set_target_output_directories(${libname} ${output_dir_${libname}}) set_target_properties(${libname} PROPERTIES OUTPUT_NAME ${output_name_${libname}}) set_target_properties(${libname} PROPERTIES FOLDER "Compiler-RT Runtime") if(LIB_LINK_LIBS) target_link_libraries(${libname} ${LIB_LINK_LIBS}) endif() if(${type} STREQUAL "SHARED") if(COMMAND llvm_setup_rpath) llvm_setup_rpath(${libname}) endif() if(WIN32 AND NOT CYGWIN AND NOT MINGW) set_target_properties(${libname} PROPERTIES IMPORT_PREFIX "") set_target_properties(${libname} PROPERTIES IMPORT_SUFFIX ".lib") endif() if(APPLE) # Ad-hoc sign the dylibs add_custom_command(TARGET ${libname} POST_BUILD COMMAND codesign --sign - $ WORKING_DIRECTORY ${COMPILER_RT_LIBRARY_OUTPUT_DIR} ) endif() endif() install(TARGETS ${libname} ARCHIVE DESTINATION ${install_dir_${libname}} ${COMPONENT_OPTION} LIBRARY DESTINATION ${install_dir_${libname}} ${COMPONENT_OPTION} RUNTIME DESTINATION ${install_dir_${libname}} ${COMPONENT_OPTION}) # We only want to generate per-library install targets if you aren't using # an IDE because the extra targets get cluttered in IDEs. if(NOT CMAKE_CONFIGURATION_TYPES) add_custom_target(install-${libname} DEPENDS ${libname} COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=${libname} -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") add_custom_target(install-${libname}-stripped DEPENDS ${libname} COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=${libname} -DCMAKE_INSTALL_DO_STRIP=1 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") # If you have a parent target specified, we bind the new install target # to the parent install target. if(LIB_PARENT_TARGET) add_dependencies(install-${LIB_PARENT_TARGET} install-${libname}) add_dependencies(install-${LIB_PARENT_TARGET}-stripped install-${libname}-stripped) endif() endif() if(APPLE) set_target_properties(${libname} PROPERTIES OSX_ARCHITECTURES "${LIB_ARCHS_${libname}}") endif() if(type STREQUAL "SHARED") rt_externalize_debuginfo(${libname}) endif() endforeach() if(LIB_PARENT_TARGET) add_dependencies(${LIB_PARENT_TARGET} ${libnames}) endif() endfunction() # when cross compiling, COMPILER_RT_TEST_COMPILER_CFLAGS help # in compilation and linking of unittests. string(REPLACE " " ";" COMPILER_RT_UNITTEST_CFLAGS "${COMPILER_RT_TEST_COMPILER_CFLAGS}") set(COMPILER_RT_UNITTEST_LINK_FLAGS ${COMPILER_RT_UNITTEST_CFLAGS}) # Unittests support. set(COMPILER_RT_GTEST_PATH ${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest) set(COMPILER_RT_GTEST_SOURCE ${COMPILER_RT_GTEST_PATH}/src/gtest-all.cc) set(COMPILER_RT_GTEST_CFLAGS -DGTEST_NO_LLVM_RAW_OSTREAM=1 -DGTEST_HAS_RTTI=0 -I${COMPILER_RT_GTEST_PATH}/include -I${COMPILER_RT_GTEST_PATH} ) append_list_if(COMPILER_RT_DEBUG -DSANITIZER_DEBUG=1 COMPILER_RT_UNITTEST_CFLAGS) append_list_if(COMPILER_RT_HAS_WCOVERED_SWITCH_DEFAULT_FLAG -Wno-covered-switch-default COMPILER_RT_UNITTEST_CFLAGS) if(MSVC) # clang doesn't support exceptions on Windows yet. list(APPEND COMPILER_RT_UNITTEST_CFLAGS -D_HAS_EXCEPTIONS=0) # We should teach clang to understand "#pragma intrinsic", see PR19898. list(APPEND COMPILER_RT_UNITTEST_CFLAGS -Wno-undefined-inline) # Clang doesn't support SEH on Windows yet. list(APPEND COMPILER_RT_GTEST_CFLAGS -DGTEST_HAS_SEH=0) # gtest use a lot of stuff marked as deprecated on Windows. list(APPEND COMPILER_RT_GTEST_CFLAGS -Wno-deprecated-declarations) endif() # Compile and register compiler-rt tests. # generate_compiler_rt_tests( # # KIND # SUBDIR # SOURCES # RUNTIME # CFLAGS # COMPILE_DEPS # DEPS # LINK_FLAGS # ) function(generate_compiler_rt_tests test_objects test_suite testname arch) cmake_parse_arguments(TEST "" "KIND;RUNTIME;SUBDIR" "SOURCES;COMPILE_DEPS;DEPS;CFLAGS;LINK_FLAGS" ${ARGN}) foreach(source ${TEST_SOURCES}) sanitizer_test_compile( "${test_objects}" "${source}" "${arch}" KIND ${TEST_KIND} COMPILE_DEPS ${TEST_COMPILE_DEPS} DEPS ${TEST_DEPS} CFLAGS ${TEST_CFLAGS} ) endforeach() set(TEST_DEPS ${${test_objects}}) if(NOT "${TEST_RUNTIME}" STREQUAL "") list(APPEND TEST_DEPS ${TEST_RUNTIME}) list(APPEND "${test_objects}" $) endif() add_compiler_rt_test(${test_suite} "${testname}" "${arch}" SUBDIR ${TEST_SUBDIR} OBJECTS ${${test_objects}} DEPS ${TEST_DEPS} LINK_FLAGS ${TEST_LINK_FLAGS} ) set("${test_objects}" "${${test_objects}}" PARENT_SCOPE) endfunction() # Link objects into a single executable with COMPILER_RT_TEST_COMPILER, # using specified link flags. Make executable a part of provided # test_suite. # add_compiler_rt_test( # SUBDIR # OBJECTS # DEPS # LINK_FLAGS ) function(add_compiler_rt_test test_suite test_name arch) cmake_parse_arguments(TEST "" "SUBDIR" "OBJECTS;DEPS;LINK_FLAGS" "" ${ARGN}) set(output_dir ${CMAKE_CURRENT_BINARY_DIR}) if(TEST_SUBDIR) set(output_dir "${output_dir}/${TEST_SUBDIR}") endif() set(output_dir "${output_dir}/${CMAKE_CFG_INTDIR}") file(MAKE_DIRECTORY "${output_dir}") set(output_bin "${output_dir}/${test_name}") if(MSVC) set(output_bin "${output_bin}.exe") endif() # Use host compiler in a standalone build, and just-built Clang otherwise. if(NOT COMPILER_RT_STANDALONE_BUILD) list(APPEND TEST_DEPS clang) endif() get_target_flags_for_arch(${arch} TARGET_LINK_FLAGS) list(APPEND TEST_LINK_FLAGS ${TARGET_LINK_FLAGS}) # If we're not on MSVC, include the linker flags from CMAKE but override them # with the provided link flags. This ensures that flags which are required to # link programs at all are included, but the changes needed for the test # trump. With MSVC we can't do that because CMake is set up to run link.exe # when linking, not the compiler. Here, we hack it to use the compiler # because we want to use -fsanitize flags. if(NOT MSVC) set(TEST_LINK_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${TEST_LINK_FLAGS}") separate_arguments(TEST_LINK_FLAGS) endif() add_custom_command( OUTPUT "${output_bin}" COMMAND ${COMPILER_RT_TEST_COMPILER} ${TEST_OBJECTS} -o "${output_bin}" ${TEST_LINK_FLAGS} DEPENDS ${TEST_DEPS} ) add_custom_target(T${test_name} DEPENDS "${output_bin}") set_target_properties(T${test_name} PROPERTIES FOLDER "Compiler-RT Tests") # Make the test suite depend on the binary. add_dependencies(${test_suite} T${test_name}) endfunction() macro(add_compiler_rt_resource_file target_name file_name component) set(src_file "${CMAKE_CURRENT_SOURCE_DIR}/${file_name}") set(dst_file "${COMPILER_RT_OUTPUT_DIR}/share/${file_name}") add_custom_command(OUTPUT ${dst_file} DEPENDS ${src_file} COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src_file} ${dst_file} COMMENT "Copying ${file_name}...") add_custom_target(${target_name} DEPENDS ${dst_file}) # Install in Clang resource directory. install(FILES ${file_name} DESTINATION ${COMPILER_RT_INSTALL_PATH}/share COMPONENT ${component}) add_dependencies(${component} ${target_name}) set_target_properties(${target_name} PROPERTIES FOLDER "Compiler-RT Misc") endmacro() macro(add_compiler_rt_script name) set(dst ${COMPILER_RT_EXEC_OUTPUT_DIR}/${name}) set(src ${CMAKE_CURRENT_SOURCE_DIR}/${name}) add_custom_command(OUTPUT ${dst} DEPENDS ${src} COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst} COMMENT "Copying ${name}...") add_custom_target(${name} DEPENDS ${dst}) install(FILES ${dst} PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE DESTINATION ${COMPILER_RT_INSTALL_PATH}/bin) endmacro(add_compiler_rt_script src name) # Builds custom version of libc++ and installs it in . # Can be used to build sanitized versions of libc++ for running unit tests. # add_custom_libcxx( # DEPS # CFLAGS # USE_TOOLCHAIN) macro(add_custom_libcxx name prefix) if(NOT COMPILER_RT_LIBCXX_PATH) message(FATAL_ERROR "libcxx not found!") endif() if(NOT COMPILER_RT_LIBCXXABI_PATH) message(FATAL_ERROR "libcxxabi not found!") endif() cmake_parse_arguments(LIBCXX "USE_TOOLCHAIN" "" "DEPS;CFLAGS;CMAKE_ARGS" ${ARGN}) if(LIBCXX_USE_TOOLCHAIN) set(compiler_args -DCMAKE_C_COMPILER=${COMPILER_RT_TEST_COMPILER} -DCMAKE_CXX_COMPILER=${COMPILER_RT_TEST_CXX_COMPILER}) if(NOT COMPILER_RT_STANDALONE_BUILD) set(toolchain_deps $) set(force_deps DEPENDS $) endif() else() set(compiler_args -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}) endif() set(STAMP_DIR ${prefix}-stamps/) set(BINARY_DIR ${prefix}-bins/) add_custom_target(${name}-clear COMMAND ${CMAKE_COMMAND} -E remove_directory ${BINARY_DIR} COMMAND ${CMAKE_COMMAND} -E remove_directory ${STAMP_DIR} COMMENT "Clobbering ${name} build and stamp directories" USES_TERMINAL ) set_target_properties(${name}-clear PROPERTIES FOLDER "Compiler-RT Misc") add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp DEPENDS ${LIBCXX_DEPS} ${toolchain_deps} COMMAND ${CMAKE_COMMAND} -E touch ${BINARY_DIR}/CMakeCache.txt COMMAND ${CMAKE_COMMAND} -E touch ${STAMP_DIR}/${name}-mkdir COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp COMMENT "Clobbering bootstrap build and stamp directories" ) add_custom_target(${name}-clobber DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp) set_target_properties(${name}-clobber PROPERTIES FOLDER "Compiler-RT Misc") set(PASSTHROUGH_VARIABLES CMAKE_C_COMPILER_TARGET CMAKE_CXX_COMPILER_TARGET CMAKE_INSTALL_PREFIX CMAKE_MAKE_PROGRAM CMAKE_LINKER CMAKE_AR CMAKE_RANLIB CMAKE_NM CMAKE_OBJCOPY CMAKE_OBJDUMP CMAKE_STRIP CMAKE_SYSROOT CMAKE_SYSTEM_NAME) foreach(variable ${PASSTHROUGH_VARIABLES}) if(${variable}) list(APPEND CMAKE_PASSTHROUGH_VARIABLES -D${variable}=${${variable}}) endif() endforeach() string(REPLACE ";" " " FLAGS_STRING "${LIBCXX_CFLAGS}") set(LIBCXX_C_FLAGS "${FLAGS_STRING}") set(LIBCXX_CXX_FLAGS "${FLAGS_STRING}") ExternalProject_Add(${name} DEPENDS ${name}-clobber ${LIBCXX_DEPS} PREFIX ${prefix} SOURCE_DIR ${COMPILER_RT_SOURCE_DIR}/cmake/CustomLibcxx STAMP_DIR ${STAMP_DIR} BINARY_DIR ${BINARY_DIR} CMAKE_ARGS ${CMAKE_PASSTHROUGH_VARIABLES} ${compiler_args} -DCMAKE_C_FLAGS=${LIBCXX_C_FLAGS} -DCMAKE_CXX_FLAGS=${LIBCXX_CXX_FLAGS} -DCMAKE_BUILD_TYPE=Release -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY -DLLVM_PATH=${LLVM_MAIN_SRC_DIR} -DLLVM_BINARY_DIR=${prefix} -DLLVM_LIBRARY_OUTPUT_INTDIR=${prefix}/lib -DCOMPILER_RT_LIBCXX_PATH=${COMPILER_RT_LIBCXX_PATH} -DCOMPILER_RT_LIBCXXABI_PATH=${COMPILER_RT_LIBCXXABI_PATH} ${LIBCXX_CMAKE_ARGS} INSTALL_COMMAND "" STEP_TARGETS configure build BUILD_ALWAYS 1 USES_TERMINAL_CONFIGURE 1 USES_TERMINAL_BUILD 1 USES_TERMINAL_INSTALL 1 EXCLUDE_FROM_ALL TRUE BUILD_BYPRODUCTS "${prefix}/lib/libc++.a" "${prefix}/lib/libc++abi.a" ) if (CMAKE_GENERATOR MATCHES "Make") set(run_clean "$(MAKE)" "-C" "${BINARY_DIR}" "clean") else() set(run_clean ${CMAKE_COMMAND} --build ${BINARY_DIR} --target clean --config "$") endif() ExternalProject_Add_Step(${name} clean COMMAND ${run_clean} COMMENT "Cleaning ${name}..." DEPENDEES configure ${force_deps} WORKING_DIRECTORY ${BINARY_DIR} EXCLUDE_FROM_MAIN 1 USES_TERMINAL 1 ) ExternalProject_Add_StepTargets(${name} clean) if(LIBCXX_USE_TOOLCHAIN) add_dependencies(${name}-clean ${name}-clobber) set_target_properties(${name}-clean PROPERTIES SOURCES ${CMAKE_CURRENT_BINARY_DIR}/${name}-clobber-stamp) endif() endmacro() function(rt_externalize_debuginfo name) if(NOT COMPILER_RT_EXTERNALIZE_DEBUGINFO) return() endif() if(NOT COMPILER_RT_EXTERNALIZE_DEBUGINFO_SKIP_STRIP) set(strip_command COMMAND xcrun strip -Sl $) endif() if(APPLE) if(CMAKE_CXX_FLAGS MATCHES "-flto" OR CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE} MATCHES "-flto") set(lto_object ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${name}-lto.o) set_property(TARGET ${name} APPEND_STRING PROPERTY LINK_FLAGS " -Wl,-object_path_lto -Wl,${lto_object}") endif() add_custom_command(TARGET ${name} POST_BUILD COMMAND xcrun dsymutil $ ${strip_command}) else() message(FATAL_ERROR "COMPILER_RT_EXTERNALIZE_DEBUGINFO isn't implemented for non-darwin platforms!") endif() endfunction() # Configure lit configuration files, including compiler-rt specific variables. function(configure_compiler_rt_lit_site_cfg input output) set_llvm_build_mode() get_compiler_rt_output_dir(${COMPILER_RT_DEFAULT_TARGET_ARCH} output_dir) string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} COMPILER_RT_RESOLVED_TEST_COMPILER ${COMPILER_RT_TEST_COMPILER}) string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} COMPILER_RT_RESOLVED_LIBRARY_OUTPUT_DIR ${output_dir}) configure_lit_site_cfg(${input} ${output}) endfunction() ================================================ FILE: runtime/cmake/BuiltinTests.cmake ================================================ include(CMakeCheckCompilerFlagCommonPatterns) # This function takes an OS and a list of architectures and identifies the # subset of the architectures list that the installed toolchain can target. function(try_compile_only output) cmake_parse_arguments(ARG "" "" "SOURCE;FLAGS" ${ARGN}) if(NOT ARG_SOURCE) set(ARG_SOURCE "int foo(int x, int y) { return x + y; }\n") endif() set(SIMPLE_C ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/src.c) file(WRITE ${SIMPLE_C} "${ARG_SOURCE}\n") string(REGEX MATCHALL "<[A-Za-z0-9_]*>" substitutions ${CMAKE_C_COMPILE_OBJECT}) set(TRY_COMPILE_FLAGS "${ARG_FLAGS}") if(CMAKE_C_COMPILER_ID MATCHES Clang AND CMAKE_C_COMPILER_TARGET) list(APPEND TRY_COMPILE_FLAGS "-target ${CMAKE_C_COMPILER_TARGET}") endif() string(REPLACE ";" " " extra_flags "${TRY_COMPILE_FLAGS}") set(test_compile_command "${CMAKE_C_COMPILE_OBJECT}") foreach(substitution ${substitutions}) if(substitution STREQUAL "") string(REPLACE "" "${CMAKE_C_COMPILER}" test_compile_command ${test_compile_command}) elseif(substitution STREQUAL "") string(REPLACE "" "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/test.o" test_compile_command ${test_compile_command}) elseif(substitution STREQUAL "") string(REPLACE "" "${SIMPLE_C}" test_compile_command ${test_compile_command}) elseif(substitution STREQUAL "") string(REPLACE "" "${CMAKE_C_FLAGS} ${extra_flags}" test_compile_command ${test_compile_command}) else() string(REPLACE "${substitution}" "" test_compile_command ${test_compile_command}) endif() endforeach() string(REPLACE " " ";" test_compile_command "${test_compile_command}") execute_process( COMMAND ${test_compile_command} RESULT_VARIABLE result OUTPUT_VARIABLE TEST_OUTPUT ERROR_VARIABLE TEST_ERROR ) CHECK_COMPILER_FLAG_COMMON_PATTERNS(_CheckCCompilerFlag_COMMON_PATTERNS) set(ERRORS_FOUND OFF) foreach(var ${_CheckCCompilerFlag_COMMON_PATTERNS}) if("${var}" STREQUAL "FAIL_REGEX") continue() endif() if("${TEST_ERROR}" MATCHES "${var}" OR "${TEST_OUTPUT}" MATCHES "${var}") set(ERRORS_FOUND ON) endif() endforeach() if(result EQUAL 0 AND NOT ERRORS_FOUND) set(${output} True PARENT_SCOPE) else() file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Testing compiler for supporting " ${ARGN} ":\n" "Command: ${test_compile_command}\n" "${TEST_OUTPUT}\n${TEST_ERROR}\n${result}\n") set(${output} False PARENT_SCOPE) endif() endfunction() function(builtin_check_c_compiler_flag flag output) if(NOT DEFINED ${output}) message(STATUS "Performing Test ${output}") try_compile_only(result FLAGS ${flag}) set(${output} ${result} CACHE INTERNAL "Compiler supports ${flag}") if(${result}) message(STATUS "Performing Test ${output} - Success") else() message(STATUS "Performing Test ${output} - Failed") endif() endif() endfunction() function(builtin_check_c_compiler_source output source) if(NOT DEFINED ${output}) message(STATUS "Performing Test ${output}") try_compile_only(result SOURCE ${source}) set(${output} ${result} CACHE INTERNAL "Compiler supports ${flag}") if(${result}) message(STATUS "Performing Test ${output} - Success") else() message(STATUS "Performing Test ${output} - Failed") endif() endif() endfunction() ================================================ FILE: runtime/cmake/CompilerRTCompile.cmake ================================================ include(CMakePushCheckState) include(CheckSymbolExists) # Because compiler-rt spends a lot of time setting up custom compile flags, # define a handy helper function for it. The compile flags setting in CMake # has serious issues that make its syntax challenging at best. function(set_target_compile_flags target) set(argstring "") foreach(arg ${ARGN}) set(argstring "${argstring} ${arg}") endforeach() set_property(TARGET ${target} PROPERTY COMPILE_FLAGS "${argstring}") endfunction() function(set_target_link_flags target) set(argstring "") foreach(arg ${ARGN}) set(argstring "${argstring} ${arg}") endforeach() set_property(TARGET ${target} PROPERTY LINK_FLAGS "${argstring}") endfunction() # Set the variable var_PYBOOL to True if var holds a true-ish string, # otherwise set it to False. macro(pythonize_bool var) if (${var}) set(${var}_PYBOOL True) else() set(${var}_PYBOOL False) endif() endmacro() # Appends value to all lists in ARGN, if the condition is true. macro(append_list_if condition value) if(${condition}) foreach(list ${ARGN}) list(APPEND ${list} ${value}) endforeach() endif() endmacro() # Appends value to all strings in ARGN, if the condition is true. macro(append_string_if condition value) if(${condition}) foreach(str ${ARGN}) set(${str} "${${str}} ${value}") endforeach() endif() endmacro() macro(append_rtti_flag polarity list) if(${polarity}) append_list_if(COMPILER_RT_HAS_FRTTI_FLAG -frtti ${list}) append_list_if(COMPILER_RT_HAS_GR_FLAG /GR ${list}) else() append_list_if(COMPILER_RT_HAS_FNO_RTTI_FLAG -fno-rtti ${list}) append_list_if(COMPILER_RT_HAS_GR_FLAG /GR- ${list}) endif() endmacro() macro(list_intersect output input1 input2) set(${output}) foreach(it ${${input1}}) list(FIND ${input2} ${it} index) if( NOT (index EQUAL -1)) list(APPEND ${output} ${it}) endif() endforeach() endmacro() function(list_replace input_list old new) set(replaced_list) foreach(item ${${input_list}}) if(${item} STREQUAL ${old}) list(APPEND replaced_list ${new}) else() list(APPEND replaced_list ${item}) endif() endforeach() set(${input_list} "${replaced_list}" PARENT_SCOPE) endfunction() # Takes ${ARGN} and puts only supported architectures in @out_var list. function(filter_available_targets out_var) set(archs ${${out_var}}) foreach(arch ${ARGN}) list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX) if(NOT (ARCH_INDEX EQUAL -1) AND CAN_TARGET_${arch}) list(APPEND archs ${arch}) endif() endforeach() set(${out_var} ${archs} PARENT_SCOPE) endfunction() # Add $arch as supported with no additional flags. macro(add_default_target_arch arch) set(TARGET_${arch}_CFLAGS "") set(CAN_TARGET_${arch} 1) list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch}) endmacro() function(check_compile_definition def argstring out_var) if("${def}" STREQUAL "") set(${out_var} TRUE PARENT_SCOPE) return() endif() cmake_push_check_state() set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${argstring}") check_symbol_exists(${def} "" ${out_var}) cmake_pop_check_state() endfunction() # test_target_arch( ) # Checks if architecture is supported: runs host compiler with provided # flags to verify that: # 1) is defined (if non-empty) # 2) simple file can be successfully built. # If successful, saves target flags for this architecture. macro(test_target_arch arch def) set(TARGET_${arch}_CFLAGS ${ARGN}) set(TARGET_${arch}_LINK_FLAGS ${ARGN}) set(argstring "") foreach(arg ${ARGN}) set(argstring "${argstring} ${arg}") endforeach() check_compile_definition("${def}" "${argstring}" HAS_${arch}_DEF) if(NOT DEFINED CAN_TARGET_${arch}) if(NOT HAS_${arch}_DEF) set(CAN_TARGET_${arch} FALSE) elseif(TEST_COMPILE_ONLY) try_compile_only(CAN_TARGET_${arch} FLAGS ${TARGET_${arch}_CFLAGS}) else() set(FLAG_NO_EXCEPTIONS "") if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG) set(FLAG_NO_EXCEPTIONS " -fno-exceptions ") endif() set(SAVED_CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS}) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${argstring}") try_compile(CAN_TARGET_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_SOURCE} COMPILE_DEFINITIONS "${TARGET_${arch}_CFLAGS} ${FLAG_NO_EXCEPTIONS}" OUTPUT_VARIABLE TARGET_${arch}_OUTPUT) set(CMAKE_EXE_LINKER_FLAGS ${SAVED_CMAKE_EXE_LINKER_FLAGS}) endif() endif() if(${CAN_TARGET_${arch}}) list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch}) elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" STREQUAL "${arch}" AND COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE) # Bail out if we cannot target the architecture we plan to test. message(FATAL_ERROR "Cannot compile for ${arch}:\n${TARGET_${arch}_OUTPUT}") endif() endmacro() macro(detect_target_arch) check_symbol_exists(__arm__ "" __ARM) check_symbol_exists(__aarch64__ "" __AARCH64) check_symbol_exists(__x86_64__ "" __X86_64) check_symbol_exists(__i386__ "" __I386) check_symbol_exists(__mips__ "" __MIPS) check_symbol_exists(__mips64__ "" __MIPS64) check_symbol_exists(__powerpc64__ "" __PPC64) check_symbol_exists(__powerpc64le__ "" __PPC64LE) check_symbol_exists(__riscv "" __RISCV) check_symbol_exists(__s390x__ "" __S390X) check_symbol_exists(__sparc "" __SPARC) check_symbol_exists(__sparcv9 "" __SPARCV9) check_symbol_exists(__wasm32__ "" __WEBASSEMBLY32) check_symbol_exists(__wasm64__ "" __WEBASSEMBLY64) check_symbol_exists(__ve__ "" __VE) if(__ARM) add_default_target_arch(arm) elseif(__AARCH64) add_default_target_arch(aarch64) elseif(__X86_64) add_default_target_arch(x86_64) elseif(__I386) add_default_target_arch(i386) elseif(__MIPS64) # must be checked before __MIPS add_default_target_arch(mips64) elseif(__MIPS) add_default_target_arch(mips) elseif(__PPC64) add_default_target_arch(powerpc64) elseif(__PPC64LE) add_default_target_arch(powerpc64le) elseif(__RISCV) if(CMAKE_SIZEOF_VOID_P EQUAL "4") add_default_target_arch(riscv32) elseif(CMAKE_SIZEOF_VOID_P EQUAL "8") add_default_target_arch(riscv64) else() message(FATAL_ERROR "Unsupport XLEN for RISC-V") endif() elseif(__S390X) add_default_target_arch(s390x) elseif(__SPARCV9) add_default_target_arch(sparcv9) elseif(__SPARC) add_default_target_arch(sparc) elseif(__WEBASSEMBLY32) add_default_target_arch(wasm32) elseif(__WEBASSEMBLY64) add_default_target_arch(wasm64) elseif(__VE) add_default_target_arch(ve) endif() endmacro() macro(load_llvm_config) if (NOT LLVM_CONFIG_PATH) find_program(LLVM_CONFIG_PATH "llvm-config" DOC "Path to llvm-config binary") if (NOT LLVM_CONFIG_PATH) message(WARNING "UNSUPPORTED COMPILER-RT CONFIGURATION DETECTED: " "llvm-config not found.\n" "Reconfigure with -DLLVM_CONFIG_PATH=path/to/llvm-config.") endif() endif() if (LLVM_CONFIG_PATH) execute_process( COMMAND ${LLVM_CONFIG_PATH} "--obj-root" "--bindir" "--libdir" "--src-root" "--includedir" RESULT_VARIABLE HAD_ERROR OUTPUT_VARIABLE CONFIG_OUTPUT) if (HAD_ERROR) message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}") endif() string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) list(GET CONFIG_OUTPUT 0 BINARY_DIR) list(GET CONFIG_OUTPUT 1 TOOLS_BINARY_DIR) list(GET CONFIG_OUTPUT 2 LIBRARY_DIR) list(GET CONFIG_OUTPUT 3 MAIN_SRC_DIR) list(GET CONFIG_OUTPUT 4 INCLUDE_DIR) set(LLVM_BINARY_DIR ${BINARY_DIR} CACHE PATH "Path to LLVM build tree") set(LLVM_LIBRARY_DIR ${LIBRARY_DIR} CACHE PATH "Path to llvm/lib") set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree") set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin") set(LLVM_INCLUDE_DIR ${INCLUDE_DIR} CACHE PATH "Paths to LLVM headers") # Detect if we have the LLVMXRay and TestingSupport library installed and # available from llvm-config. execute_process( COMMAND ${LLVM_CONFIG_PATH} "--ldflags" "--libs" "xray" RESULT_VARIABLE HAD_ERROR OUTPUT_VARIABLE CONFIG_OUTPUT ERROR_QUIET) if (HAD_ERROR) message(WARNING "llvm-config finding xray failed with status ${HAD_ERROR}") set(COMPILER_RT_HAS_LLVMXRAY FALSE) else() string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) list(GET CONFIG_OUTPUT 0 LDFLAGS) list(GET CONFIG_OUTPUT 1 LIBLIST) file(TO_CMAKE_PATH "${LDFLAGS}" LDFLAGS) file(TO_CMAKE_PATH "${LIBLIST}" LIBLIST) set(LLVM_XRAY_LDFLAGS ${LDFLAGS} CACHE STRING "Linker flags for LLVMXRay library") set(LLVM_XRAY_LIBLIST ${LIBLIST} CACHE STRING "Library list for LLVMXRay") set(COMPILER_RT_HAS_LLVMXRAY TRUE) endif() set(COMPILER_RT_HAS_LLVMTESTINGSUPPORT FALSE) execute_process( COMMAND ${LLVM_CONFIG_PATH} "--ldflags" "--libs" "testingsupport" RESULT_VARIABLE HAD_ERROR OUTPUT_VARIABLE CONFIG_OUTPUT ERROR_QUIET) if (HAD_ERROR) message(WARNING "llvm-config finding testingsupport failed with status ${HAD_ERROR}") elseif(COMPILER_RT_INCLUDE_TESTS) string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) list(GET CONFIG_OUTPUT 0 LDFLAGS) list(GET CONFIG_OUTPUT 1 LIBLIST) if (LIBLIST STREQUAL "") message(WARNING "testingsupport library not installed, some tests will be skipped") else() file(TO_CMAKE_PATH "${LDFLAGS}" LDFLAGS) file(TO_CMAKE_PATH "${LIBLIST}" LIBLIST) set(LLVM_TESTINGSUPPORT_LDFLAGS ${LDFLAGS} CACHE STRING "Linker flags for LLVMTestingSupport library") set(LLVM_TESTINGSUPPORT_LIBLIST ${LIBLIST} CACHE STRING "Library list for LLVMTestingSupport") set(COMPILER_RT_HAS_LLVMTESTINGSUPPORT TRUE) endif() endif() # Make use of LLVM CMake modules. # --cmakedir is supported since llvm r291218 (4.0 release) execute_process( COMMAND ${LLVM_CONFIG_PATH} --cmakedir RESULT_VARIABLE HAD_ERROR OUTPUT_VARIABLE CONFIG_OUTPUT) if(NOT HAD_ERROR) string(STRIP "${CONFIG_OUTPUT}" LLVM_CMAKE_PATH_FROM_LLVM_CONFIG) file(TO_CMAKE_PATH ${LLVM_CMAKE_PATH_FROM_LLVM_CONFIG} LLVM_CMAKE_PATH) else() file(TO_CMAKE_PATH ${LLVM_BINARY_DIR} LLVM_BINARY_DIR_CMAKE_STYLE) set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR_CMAKE_STYLE}/lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm") endif() list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}") # Get some LLVM variables from LLVMConfig. include("${LLVM_CMAKE_PATH}/LLVMConfig.cmake") set(LLVM_LIBRARY_OUTPUT_INTDIR ${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX}) endif() endmacro() macro(construct_compiler_rt_default_triple) if(COMPILER_RT_DEFAULT_TARGET_ONLY) if(DEFINED COMPILER_RT_DEFAULT_TARGET_TRIPLE) message(FATAL_ERROR "COMPILER_RT_DEFAULT_TARGET_TRIPLE isn't supported when building for default target only") endif() set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${CMAKE_C_COMPILER_TARGET}) else() set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${TARGET_TRIPLE} CACHE STRING "Default triple for which compiler-rt runtimes will be built.") endif() if(DEFINED COMPILER_RT_TEST_TARGET_TRIPLE) # Backwards compatibility: this variable used to be called # COMPILER_RT_TEST_TARGET_TRIPLE. set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${COMPILER_RT_TEST_TARGET_TRIPLE}) endif() string(REPLACE "-" ";" TARGET_TRIPLE_LIST ${COMPILER_RT_DEFAULT_TARGET_TRIPLE}) list(GET TARGET_TRIPLE_LIST 0 COMPILER_RT_DEFAULT_TARGET_ARCH) # Determine if test target triple is specified explicitly, and doesn't match the # default. if(NOT COMPILER_RT_DEFAULT_TARGET_TRIPLE STREQUAL TARGET_TRIPLE) set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE TRUE) else() set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE FALSE) endif() endmacro() # Filter out generic versions of routines that are re-implemented in an # architecture specific manner. This prevents multiple definitions of the same # symbols, making the symbol selection non-deterministic. # # We follow the convention that a source file that exists in a sub-directory # (e.g. `ppc/divtc3.c`) is architecture-specific and that if a generic # implementation exists it will be a top-level source file with the same name # modulo the file extension (e.g. `divtc3.c`). function(filter_builtin_sources inout_var name) set(intermediate ${${inout_var}}) foreach(_file ${intermediate}) get_filename_component(_file_dir ${_file} DIRECTORY) if (NOT "${_file_dir}" STREQUAL "") # Architecture specific file. If a generic version exists, print a notice # and ensure that it is removed from the file list. get_filename_component(_name ${_file} NAME) string(REGEX REPLACE "\\.S$" ".c" _cname "${_name}") if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${_cname}") message(STATUS "For ${name} builtins preferring ${_file} to ${_cname}") list(REMOVE_ITEM intermediate ${_cname}) endif() endif() endforeach() set(${inout_var} ${intermediate} PARENT_SCOPE) endfunction() function(get_compiler_rt_target arch variable) string(FIND ${COMPILER_RT_DEFAULT_TARGET_TRIPLE} "-" dash_index) string(SUBSTRING ${COMPILER_RT_DEFAULT_TARGET_TRIPLE} ${dash_index} -1 triple_suffix) if(COMPILER_RT_DEFAULT_TARGET_ONLY) # Use exact spelling when building only for the target specified to CMake. set(target "${COMPILER_RT_DEFAULT_TARGET_TRIPLE}") elseif(ANDROID AND ${arch} STREQUAL "i386") set(target "i686${triple_suffix}") else() set(target "${arch}${triple_suffix}") endif() set(${variable} ${target} PARENT_SCOPE) endfunction() function(get_compiler_rt_install_dir arch install_dir) if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE) get_compiler_rt_target(${arch} target) set(${install_dir} ${COMPILER_RT_INSTALL_PATH}/lib/${target} PARENT_SCOPE) else() set(${install_dir} ${COMPILER_RT_LIBRARY_INSTALL_DIR} PARENT_SCOPE) endif() endfunction() function(get_compiler_rt_output_dir arch output_dir) if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE) get_compiler_rt_target(${arch} target) set(${output_dir} ${COMPILER_RT_OUTPUT_DIR}/lib/${target} PARENT_SCOPE) else() set(${output_dir} ${COMPILER_RT_LIBRARY_OUTPUT_DIR} PARENT_SCOPE) endif() endfunction() # compiler_rt_process_sources( # # ... # [ADDITIONAL_HEADERS
...] # ) # # Process the provided sources and write the list of new sources # into ``. # # ADDITIONAL_HEADERS - Adds the supplied header to list of sources for IDEs. # # This function is very similar to `llvm_process_sources()` but exists here # because we need to support standalone builds of compiler-rt. function(compiler_rt_process_sources OUTPUT_VAR) cmake_parse_arguments( ARG "" "" "ADDITIONAL_HEADERS" ${ARGN} ) set(sources ${ARG_UNPARSED_ARGUMENTS}) set(headers "") if (XCODE OR MSVC_IDE OR CMAKE_EXTRA_GENERATOR) # For IDEs we need to tell CMake about header files. # Otherwise they won't show up in UI. set(headers ${ARG_ADDITIONAL_HEADERS}) list(LENGTH headers headers_length) if (${headers_length} GREATER 0) set_source_files_properties(${headers} PROPERTIES HEADER_FILE_ONLY ON) endif() endif() set("${OUTPUT_VAR}" ${sources} ${headers} PARENT_SCOPE) endfunction() # Create install targets for a library and its parent component (if specified). function(add_compiler_rt_install_targets name) cmake_parse_arguments(ARG "" "PARENT_TARGET" "" ${ARGN}) if(ARG_PARENT_TARGET AND NOT TARGET install-${ARG_PARENT_TARGET}) # The parent install target specifies the parent component to scrape up # anything not installed by the individual install targets, and to handle # installation when running the multi-configuration generators. add_custom_target(install-${ARG_PARENT_TARGET} DEPENDS ${ARG_PARENT_TARGET} COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=${ARG_PARENT_TARGET} -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") add_custom_target(install-${ARG_PARENT_TARGET}-stripped DEPENDS ${ARG_PARENT_TARGET} COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=${ARG_PARENT_TARGET} -DCMAKE_INSTALL_DO_STRIP=1 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") set_target_properties(install-${ARG_PARENT_TARGET} PROPERTIES FOLDER "Compiler-RT Misc") set_target_properties(install-${ARG_PARENT_TARGET}-stripped PROPERTIES FOLDER "Compiler-RT Misc") add_dependencies(install-compiler-rt install-${ARG_PARENT_TARGET}) add_dependencies(install-compiler-rt-stripped install-${ARG_PARENT_TARGET}-stripped) endif() # We only want to generate per-library install targets if you aren't using # an IDE because the extra targets get cluttered in IDEs. if(NOT CMAKE_CONFIGURATION_TYPES) add_custom_target(install-${name} DEPENDS ${name} COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=${name} -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") add_custom_target(install-${name}-stripped DEPENDS ${name} COMMAND "${CMAKE_COMMAND}" -DCMAKE_INSTALL_COMPONENT=${name} -DCMAKE_INSTALL_DO_STRIP=1 -P "${CMAKE_BINARY_DIR}/cmake_install.cmake") # If you have a parent target specified, we bind the new install target # to the parent install target. if(LIB_PARENT_TARGET) add_dependencies(install-${LIB_PARENT_TARGET} install-${name}) add_dependencies(install-${LIB_PARENT_TARGET}-stripped install-${name}-stripped) endif() endif() endfunction() ================================================ FILE: runtime/cmake/CompilerRTDarwinUtils.cmake ================================================ include(CMakeParseArguments) # On OS X SDKs can be installed anywhere on the base system and xcode-select can # set the default Xcode to use. This function finds the SDKs that are present in # the current Xcode. function(find_darwin_sdk_dir var sdk_name) set(DARWIN_${sdk_name}_CACHED_SYSROOT "" CACHE STRING "Darwin SDK path for SDK ${sdk_name}.") set(DARWIN_PREFER_PUBLIC_SDK OFF CACHE BOOL "Prefer Darwin public SDK, even when an internal SDK is present.") if(DARWIN_${sdk_name}_CACHED_SYSROOT) set(${var} ${DARWIN_${sdk_name}_CACHED_SYSROOT} PARENT_SCOPE) return() endif() if(NOT DARWIN_PREFER_PUBLIC_SDK) # Let's first try the internal SDK, otherwise use the public SDK. execute_process( COMMAND xcodebuild -version -sdk ${sdk_name}.internal Path RESULT_VARIABLE result_process OUTPUT_VARIABLE var_internal OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_FILE /dev/null ) endif() if((NOT result_process EQUAL 0) OR "" STREQUAL "${var_internal}") execute_process( COMMAND xcodebuild -version -sdk ${sdk_name} Path RESULT_VARIABLE result_process OUTPUT_VARIABLE var_internal OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_FILE /dev/null ) else() set(${var}_INTERNAL ${var_internal} PARENT_SCOPE) endif() if(result_process EQUAL 0) set(${var} ${var_internal} PARENT_SCOPE) endif() set(DARWIN_${sdk_name}_CACHED_SYSROOT ${var_internal} CACHE STRING "Darwin SDK path for SDK ${sdk_name}." FORCE) endfunction() # There isn't a clear mapping of what architectures are supported with a given # target platform, but ld's version output does list the architectures it can # link for. function(darwin_get_toolchain_supported_archs output_var) execute_process( COMMAND ld -v ERROR_VARIABLE LINKER_VERSION) string(REGEX MATCH "configured to support archs: ([^\n]+)" ARCHES_MATCHED "${LINKER_VERSION}") if(ARCHES_MATCHED) set(ARCHES "${CMAKE_MATCH_1}") message(STATUS "Got ld supported ARCHES: ${ARCHES}") string(REPLACE " " ";" ARCHES ${ARCHES}) else() # If auto-detecting fails, fall back to a default set message(WARNING "Detecting supported architectures from 'ld -v' failed. Returning default set.") set(ARCHES "i386;x86_64;armv7;armv7s;arm64") endif() set(${output_var} ${ARCHES} PARENT_SCOPE) endfunction() # This function takes an OS and a list of architectures and identifies the # subset of the architectures list that the installed toolchain can target. function(darwin_test_archs os valid_archs) if(${valid_archs}) message(STATUS "Using cached valid architectures for ${os}.") return() endif() set(archs ${ARGN}) if(NOT TEST_COMPILE_ONLY) message(STATUS "Finding valid architectures for ${os}...") set(SIMPLE_C ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/src.c) file(WRITE ${SIMPLE_C} "#include \nint main() { printf(__FILE__); return 0; }\n") set(os_linker_flags) foreach(flag ${DARWIN_${os}_LINK_FLAGS}) set(os_linker_flags "${os_linker_flags} ${flag}") endforeach() endif() # The simple program will build for x86_64h on the simulator because it is # compatible with x86_64 libraries (mostly), but since x86_64h isn't actually # a valid or useful architecture for the iOS simulator we should drop it. if(${os} MATCHES "^(iossim|tvossim|watchossim)$") list(REMOVE_ITEM archs "x86_64h") endif() set(working_archs) foreach(arch ${archs}) set(arch_linker_flags "-arch ${arch} ${os_linker_flags}") if(TEST_COMPILE_ONLY) try_compile_only(CAN_TARGET_${os}_${arch} -v -arch ${arch} ${DARWIN_${os}_CFLAGS}) else() set(SAVED_CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS}) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${arch_linker_flags}") try_compile(CAN_TARGET_${os}_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_C} COMPILE_DEFINITIONS "-v -arch ${arch}" ${DARWIN_${os}_CFLAGS} OUTPUT_VARIABLE TEST_OUTPUT) set(CMAKE_EXE_LINKER_FLAGS ${SAVED_CMAKE_EXE_LINKER_FLAGS}) endif() if(${CAN_TARGET_${os}_${arch}}) list(APPEND working_archs ${arch}) else() file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "Testing compiler for supporting ${os}-${arch}:\n" "${TEST_OUTPUT}\n") endif() endforeach() set(${valid_archs} ${working_archs} CACHE STRING "List of valid architectures for platform ${os}.") endfunction() # This function checks the host cpusubtype to see if it is post-haswell. Haswell # and later machines can run x86_64h binaries. Haswell is cpusubtype 8. function(darwin_filter_host_archs input output) list_intersect(tmp_var DARWIN_osx_ARCHS ${input}) execute_process( COMMAND sysctl hw.cpusubtype OUTPUT_VARIABLE SUBTYPE) string(REGEX MATCH "hw.cpusubtype: ([0-9]*)" SUBTYPE_MATCHED "${SUBTYPE}") set(HASWELL_SUPPORTED Off) if(SUBTYPE_MATCHED) if(${CMAKE_MATCH_1} GREATER 7) set(HASWELL_SUPPORTED On) endif() endif() if(NOT HASWELL_SUPPORTED) list(REMOVE_ITEM tmp_var x86_64h) endif() set(${output} ${tmp_var} PARENT_SCOPE) endfunction() # Read and process the exclude file into a list of symbols function(darwin_read_list_from_file output_var file) if(EXISTS ${file}) file(READ ${file} EXCLUDES) string(REPLACE "\n" ";" EXCLUDES ${EXCLUDES}) set(${output_var} ${EXCLUDES} PARENT_SCOPE) endif() endfunction() # this function takes an OS, architecture and minimum version and provides a # list of builtin functions to exclude function(darwin_find_excluded_builtins_list output_var) cmake_parse_arguments(LIB "" "OS;ARCH;MIN_VERSION" "" ${ARGN}) if(NOT LIB_OS OR NOT LIB_ARCH) message(FATAL_ERROR "Must specify OS and ARCH to darwin_find_excluded_builtins_list!") endif() darwin_read_list_from_file(${LIB_OS}_BUILTINS ${DARWIN_EXCLUDE_DIR}/${LIB_OS}.txt) darwin_read_list_from_file(${LIB_OS}_${LIB_ARCH}_BASE_BUILTINS ${DARWIN_EXCLUDE_DIR}/${LIB_OS}-${LIB_ARCH}.txt) if(LIB_MIN_VERSION) file(GLOB builtin_lists ${DARWIN_EXCLUDE_DIR}/${LIB_OS}*-${LIB_ARCH}.txt) foreach(builtin_list ${builtin_lists}) string(REGEX MATCH "${LIB_OS}([0-9\\.]*)-${LIB_ARCH}.txt" VERSION_MATCHED "${builtin_list}") if (VERSION_MATCHED AND NOT CMAKE_MATCH_1 VERSION_LESS LIB_MIN_VERSION) if(NOT smallest_version) set(smallest_version ${CMAKE_MATCH_1}) elseif(CMAKE_MATCH_1 VERSION_LESS smallest_version) set(smallest_version ${CMAKE_MATCH_1}) endif() endif() endforeach() if(smallest_version) darwin_read_list_from_file(${LIB_ARCH}_${LIB_OS}_BUILTINS ${DARWIN_EXCLUDE_DIR}/${LIB_OS}${smallest_version}-${LIB_ARCH}.txt) endif() endif() set(${output_var} ${${LIB_ARCH}_${LIB_OS}_BUILTINS} ${${LIB_OS}_${LIB_ARCH}_BASE_BUILTINS} ${${LIB_OS}_BUILTINS} PARENT_SCOPE) endfunction() # adds a single builtin library for a single OS & ARCH macro(darwin_add_builtin_library name suffix) cmake_parse_arguments(LIB "" "PARENT_TARGET;OS;ARCH" "SOURCES;CFLAGS;DEFS" ${ARGN}) set(libname "${name}.${suffix}_${LIB_ARCH}_${LIB_OS}") add_library(${libname} STATIC ${LIB_SOURCES}) if(DARWIN_${LIB_OS}_SYSROOT) set(sysroot_flag -isysroot ${DARWIN_${LIB_OS}_SYSROOT}) endif() # Make a copy of the compilation flags. set(builtin_cflags ${LIB_CFLAGS}) # Strip out any inappropriate flags for the target. if("${LIB_ARCH}" MATCHES "^(armv7|armv7k|armv7s)$") set(builtin_cflags "") foreach(cflag "${LIB_CFLAGS}") string(REPLACE "-fomit-frame-pointer" "" cflag "${cflag}") list(APPEND builtin_cflags ${cflag}) endforeach(cflag) endif() set_target_compile_flags(${libname} ${sysroot_flag} ${DARWIN_${LIB_OS}_BUILTIN_MIN_VER_FLAG} ${builtin_cflags}) set_property(TARGET ${libname} APPEND PROPERTY COMPILE_DEFINITIONS ${LIB_DEFS}) set_target_properties(${libname} PROPERTIES OUTPUT_NAME ${libname}${COMPILER_RT_OS_SUFFIX}) set_target_properties(${libname} PROPERTIES OSX_ARCHITECTURES ${LIB_ARCH}) if(LIB_PARENT_TARGET) add_dependencies(${LIB_PARENT_TARGET} ${libname}) endif() list(APPEND ${LIB_OS}_${suffix}_libs ${libname}) list(APPEND ${LIB_OS}_${suffix}_lipo_flags -arch ${arch} $) endmacro() function(darwin_lipo_libs name) cmake_parse_arguments(LIB "" "PARENT_TARGET;OUTPUT_DIR;INSTALL_DIR" "LIPO_FLAGS;DEPENDS" ${ARGN}) if(LIB_DEPENDS AND LIB_LIPO_FLAGS) add_custom_command(OUTPUT ${LIB_OUTPUT_DIR}/lib${name}.a COMMAND ${CMAKE_COMMAND} -E make_directory ${LIB_OUTPUT_DIR} COMMAND lipo -output ${LIB_OUTPUT_DIR}/lib${name}.a -create ${LIB_LIPO_FLAGS} DEPENDS ${LIB_DEPENDS} ) add_custom_target(${name} DEPENDS ${LIB_OUTPUT_DIR}/lib${name}.a) add_dependencies(${LIB_PARENT_TARGET} ${name}) install(FILES ${LIB_OUTPUT_DIR}/lib${name}.a DESTINATION ${LIB_INSTALL_DIR}) else() message(WARNING "Not generating lipo target for ${name} because no input libraries exist.") endif() endfunction() # Generates builtin libraries for all operating systems specified in ARGN. Each # OS library is constructed by lipo-ing together single-architecture libraries. macro(darwin_add_builtin_libraries) set(DARWIN_EXCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/Darwin-excludes) set(CFLAGS "-fPIC -O3 -fvisibility=hidden -DVISIBILITY_HIDDEN -Wall -fomit-frame-pointer") set(CMAKE_C_FLAGS "") set(CMAKE_CXX_FLAGS "") set(CMAKE_ASM_FLAGS "") set(PROFILE_SOURCES ../profile/InstrProfiling ../profile/InstrProfilingBuffer ../profile/InstrProfilingPlatformDarwin ../profile/InstrProfilingWriter) foreach (os ${ARGN}) list_intersect(DARWIN_BUILTIN_ARCHS DARWIN_${os}_ARCHS BUILTIN_SUPPORTED_ARCH) foreach (arch ${DARWIN_BUILTIN_ARCHS}) darwin_find_excluded_builtins_list(${arch}_${os}_EXCLUDED_BUILTINS OS ${os} ARCH ${arch} MIN_VERSION ${DARWIN_${os}_BUILTIN_MIN_VER}) filter_builtin_sources(filtered_sources EXCLUDE ${arch}_${os}_EXCLUDED_BUILTINS ${${arch}_SOURCES}) darwin_add_builtin_library(clang_rt builtins OS ${os} ARCH ${arch} SOURCES ${filtered_sources} CFLAGS ${CFLAGS} -arch ${arch} PARENT_TARGET builtins) endforeach() # Don't build cc_kext libraries for simulator platforms if(NOT DARWIN_${os}_SKIP_CC_KEXT) foreach (arch ${DARWIN_BUILTIN_ARCHS}) # By not specifying MIN_VERSION this only reads the OS and OS-arch lists. # We don't want to filter out the builtins that are present in libSystem # because kexts can't link libSystem. darwin_find_excluded_builtins_list(${arch}_${os}_EXCLUDED_BUILTINS OS ${os} ARCH ${arch}) filter_builtin_sources(filtered_sources EXCLUDE ${arch}_${os}_EXCLUDED_BUILTINS ${${arch}_SOURCES}) # In addition to the builtins cc_kext includes some profile sources darwin_add_builtin_library(clang_rt cc_kext OS ${os} ARCH ${arch} SOURCES ${filtered_sources} ${PROFILE_SOURCES} CFLAGS ${CFLAGS} -arch ${arch} -mkernel DEFS KERNEL_USE PARENT_TARGET builtins) endforeach() set(archive_name clang_rt.cc_kext_${os}) if(${os} STREQUAL "osx") set(archive_name clang_rt.cc_kext) endif() darwin_lipo_libs(${archive_name} PARENT_TARGET builtins LIPO_FLAGS ${${os}_cc_kext_lipo_flags} DEPENDS ${${os}_cc_kext_libs} OUTPUT_DIR ${COMPILER_RT_LIBRARY_OUTPUT_DIR} INSTALL_DIR ${COMPILER_RT_LIBRARY_INSTALL_DIR}) endif() endforeach() # We put the x86 sim slices into the archives for their base OS foreach (os ${ARGN}) if(NOT ${os} MATCHES ".*sim$") darwin_lipo_libs(clang_rt.${os} PARENT_TARGET builtins LIPO_FLAGS ${${os}_builtins_lipo_flags} ${${os}sim_builtins_lipo_flags} DEPENDS ${${os}_builtins_libs} ${${os}sim_builtins_libs} OUTPUT_DIR ${COMPILER_RT_LIBRARY_OUTPUT_DIR} INSTALL_DIR ${COMPILER_RT_LIBRARY_INSTALL_DIR}) endif() endforeach() darwin_add_embedded_builtin_libraries() endmacro() macro(darwin_add_embedded_builtin_libraries) # this is a hacky opt-out. If you can't target both intel and arm # architectures we bail here. set(DARWIN_SOFT_FLOAT_ARCHS armv6m armv7m armv7em armv7) set(DARWIN_HARD_FLOAT_ARCHS armv7em armv7) if(COMPILER_RT_SUPPORTED_ARCH MATCHES ".*armv.*") list(FIND COMPILER_RT_SUPPORTED_ARCH i386 i386_idx) if(i386_idx GREATER -1) list(APPEND DARWIN_HARD_FLOAT_ARCHS i386) endif() list(FIND COMPILER_RT_SUPPORTED_ARCH x86_64 x86_64_idx) if(x86_64_idx GREATER -1) list(APPEND DARWIN_HARD_FLOAT_ARCHS x86_64) endif() set(MACHO_SYM_DIR ${CMAKE_CURRENT_SOURCE_DIR}/macho_embedded) set(CFLAGS "-Oz -Wall -fomit-frame-pointer -ffreestanding") set(CMAKE_C_FLAGS "") set(CMAKE_CXX_FLAGS "") set(CMAKE_ASM_FLAGS "") set(SOFT_FLOAT_FLAG -mfloat-abi=soft) set(HARD_FLOAT_FLAG -mfloat-abi=hard) set(ENABLE_PIC Off) set(PIC_FLAG -fPIC) set(STATIC_FLAG -static) set(DARWIN_macho_embedded_ARCHS armv6m armv7m armv7em armv7 i386 x86_64) set(DARWIN_macho_embedded_LIBRARY_OUTPUT_DIR ${COMPILER_RT_OUTPUT_DIR}/lib/macho_embedded) set(DARWIN_macho_embedded_LIBRARY_INSTALL_DIR ${COMPILER_RT_INSTALL_PATH}/lib/macho_embedded) set(CFLAGS_armv7 "-target thumbv7-apple-darwin-eabi") set(CFLAGS_i386 "-march=pentium") darwin_read_list_from_file(common_FUNCTIONS ${MACHO_SYM_DIR}/common.txt) darwin_read_list_from_file(thumb2_FUNCTIONS ${MACHO_SYM_DIR}/thumb2.txt) darwin_read_list_from_file(thumb2_64_FUNCTIONS ${MACHO_SYM_DIR}/thumb2-64.txt) darwin_read_list_from_file(arm_FUNCTIONS ${MACHO_SYM_DIR}/arm.txt) darwin_read_list_from_file(i386_FUNCTIONS ${MACHO_SYM_DIR}/i386.txt) set(armv6m_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS}) set(armv7m_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS} ${thumb2_FUNCTIONS}) set(armv7em_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS} ${thumb2_FUNCTIONS}) set(armv7_FUNCTIONS ${common_FUNCTIONS} ${arm_FUNCTIONS} ${thumb2_FUNCTIONS} ${thumb2_64_FUNCTIONS}) set(i386_FUNCTIONS ${common_FUNCTIONS} ${i386_FUNCTIONS}) set(x86_64_FUNCTIONS ${common_FUNCTIONS}) foreach(arch ${DARWIN_macho_embedded_ARCHS}) filter_builtin_sources(${arch}_filtered_sources INCLUDE ${arch}_FUNCTIONS ${${arch}_SOURCES}) if(NOT ${arch}_filtered_sources) message("${arch}_SOURCES: ${${arch}_SOURCES}") message("${arch}_FUNCTIONS: ${${arch}_FUNCTIONS}") message(FATAL_ERROR "Empty filtered sources!") endif() endforeach() foreach(float_type SOFT HARD) foreach(type PIC STATIC) string(TOLOWER "${float_type}_${type}" lib_suffix) foreach(arch ${DARWIN_${float_type}_FLOAT_ARCHS}) set(DARWIN_macho_embedded_SYSROOT ${DARWIN_osx_SYSROOT}) set(float_flag) if(${arch} MATCHES "^arm") # x86 targets are hard float by default, but the complain about the # float ABI flag, so don't pass it unless we're targeting arm. set(float_flag ${${float_type}_FLOAT_FLAG}) endif() darwin_add_builtin_library(clang_rt ${lib_suffix} OS macho_embedded ARCH ${arch} SOURCES ${${arch}_filtered_sources} CFLAGS ${CFLAGS} -arch ${arch} ${${type}_FLAG} ${float_flag} ${CFLAGS_${arch}} PARENT_TARGET builtins) endforeach() foreach(lib ${macho_embedded_${lib_suffix}_libs}) set_target_properties(${lib} PROPERTIES LINKER_LANGUAGE C) endforeach() darwin_lipo_libs(clang_rt.${lib_suffix} PARENT_TARGET builtins LIPO_FLAGS ${macho_embedded_${lib_suffix}_lipo_flags} DEPENDS ${macho_embedded_${lib_suffix}_libs} OUTPUT_DIR ${DARWIN_macho_embedded_LIBRARY_OUTPUT_DIR} INSTALL_DIR ${DARWIN_macho_embedded_LIBRARY_INSTALL_DIR}) endforeach() endforeach() endif() endmacro() ================================================ FILE: runtime/cmake/CompilerRTLink.cmake ================================================ # Link a shared library with COMPILER_RT_TEST_COMPILER. # clang_link_shared( # OBJECTS # LINK_FLAGS # DEPS ) macro(clang_link_shared so_file) cmake_parse_arguments(SOURCE "" "" "OBJECTS;LINK_FLAGS;DEPS" ${ARGN}) if(NOT COMPILER_RT_STANDALONE_BUILD) list(APPEND SOURCE_DEPS clang) endif() add_custom_command( OUTPUT ${so_file} COMMAND ${COMPILER_RT_TEST_COMPILER} -o "${so_file}" -shared ${SOURCE_LINK_FLAGS} ${SOURCE_OBJECTS} DEPENDS ${SOURCE_DEPS}) endmacro() ================================================ FILE: runtime/cmake/CompilerRTUtils.cmake ================================================ include(CMakePushCheckState) include(CheckSymbolExists) # Because compiler-rt spends a lot of time setting up custom compile flags, # define a handy helper function for it. The compile flags setting in CMake # has serious issues that make its syntax challenging at best. function(set_target_compile_flags target) set(argstring "") foreach(arg ${ARGN}) set(argstring "${argstring} ${arg}") endforeach() set_property(TARGET ${target} PROPERTY COMPILE_FLAGS "${argstring}") endfunction() function(set_target_link_flags target) set(argstring "") foreach(arg ${ARGN}) set(argstring "${argstring} ${arg}") endforeach() set_property(TARGET ${target} PROPERTY LINK_FLAGS "${argstring}") endfunction() # Set the variable var_PYBOOL to True if var holds a true-ish string, # otherwise set it to False. macro(pythonize_bool var) if (${var}) set(${var}_PYBOOL True) else() set(${var}_PYBOOL False) endif() endmacro() # Appends value to all lists in ARGN, if the condition is true. macro(append_list_if condition value) if(${condition}) foreach(list ${ARGN}) list(APPEND ${list} ${value}) endforeach() endif() endmacro() # Appends value to all strings in ARGN, if the condition is true. macro(append_string_if condition value) if(${condition}) foreach(str ${ARGN}) set(${str} "${${str}} ${value}") endforeach() endif() endmacro() macro(append_rtti_flag polarity list) if(${polarity}) append_list_if(COMPILER_RT_HAS_FRTTI_FLAG -frtti ${list}) append_list_if(COMPILER_RT_HAS_GR_FLAG /GR ${list}) else() append_list_if(COMPILER_RT_HAS_FNO_RTTI_FLAG -fno-rtti ${list}) append_list_if(COMPILER_RT_HAS_GR_FLAG /GR- ${list}) endif() endmacro() macro(append_have_file_definition filename varname list) check_include_file("${filename}" "${varname}") if (NOT ${varname}) set("${varname}" 0) endif() list(APPEND ${list} "${varname}=${${varname}}") endmacro() macro(list_intersect output input1 input2) set(${output}) foreach(it ${${input1}}) list(FIND ${input2} ${it} index) if( NOT (index EQUAL -1)) list(APPEND ${output} ${it}) endif() endforeach() endmacro() function(list_replace input_list old new) set(replaced_list) foreach(item ${${input_list}}) if(${item} STREQUAL ${old}) list(APPEND replaced_list ${new}) else() list(APPEND replaced_list ${item}) endif() endforeach() set(${input_list} "${replaced_list}" PARENT_SCOPE) endfunction() # Takes ${ARGN} and puts only supported architectures in @out_var list. function(filter_available_targets out_var) set(archs ${${out_var}}) foreach(arch ${ARGN}) list(FIND COMPILER_RT_SUPPORTED_ARCH ${arch} ARCH_INDEX) if(NOT (ARCH_INDEX EQUAL -1) AND CAN_TARGET_${arch}) list(APPEND archs ${arch}) endif() endforeach() set(${out_var} ${archs} PARENT_SCOPE) endfunction() # Add $arch as supported with no additional flags. macro(add_default_target_arch arch) set(TARGET_${arch}_CFLAGS "") set(CAN_TARGET_${arch} 1) list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch}) endmacro() function(check_compile_definition def argstring out_var) if("${def}" STREQUAL "") set(${out_var} TRUE PARENT_SCOPE) return() endif() cmake_push_check_state() set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${argstring}") check_symbol_exists(${def} "" ${out_var}) cmake_pop_check_state() endfunction() # test_target_arch( ) # Checks if architecture is supported: runs host compiler with provided # flags to verify that: # 1) is defined (if non-empty) # 2) simple file can be successfully built. # If successful, saves target flags for this architecture. macro(test_target_arch arch def) set(TARGET_${arch}_CFLAGS ${ARGN}) set(TARGET_${arch}_LINK_FLAGS ${ARGN}) set(argstring "") foreach(arg ${ARGN}) set(argstring "${argstring} ${arg}") endforeach() check_compile_definition("${def}" "${argstring}" HAS_${arch}_DEF) if(NOT DEFINED CAN_TARGET_${arch}) if(NOT HAS_${arch}_DEF) set(CAN_TARGET_${arch} FALSE) elseif(TEST_COMPILE_ONLY) try_compile_only(CAN_TARGET_${arch} ${TARGET_${arch}_CFLAGS}) else() set(FLAG_NO_EXCEPTIONS "") if(COMPILER_RT_HAS_FNO_EXCEPTIONS_FLAG) set(FLAG_NO_EXCEPTIONS " -fno-exceptions ") endif() set(SAVED_CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS}) set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${argstring}") try_compile(CAN_TARGET_${arch} ${CMAKE_BINARY_DIR} ${SIMPLE_SOURCE} COMPILE_DEFINITIONS "${TARGET_${arch}_CFLAGS} ${FLAG_NO_EXCEPTIONS}" OUTPUT_VARIABLE TARGET_${arch}_OUTPUT) set(CMAKE_EXE_LINKER_FLAGS ${SAVED_CMAKE_EXE_LINKER_FLAGS}) endif() endif() if(${CAN_TARGET_${arch}}) list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch}) elseif("${COMPILER_RT_DEFAULT_TARGET_ARCH}" STREQUAL "${arch}" AND COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE) # Bail out if we cannot target the architecture we plan to test. message(FATAL_ERROR "Cannot compile for ${arch}:\n${TARGET_${arch}_OUTPUT}") endif() endmacro() macro(detect_target_arch) check_symbol_exists(__arm__ "" __ARM) check_symbol_exists(__aarch64__ "" __AARCH64) check_symbol_exists(__x86_64__ "" __X86_64) check_symbol_exists(__i386__ "" __I386) check_symbol_exists(__mips__ "" __MIPS) check_symbol_exists(__mips64__ "" __MIPS64) check_symbol_exists(__powerpc64__ "" __PPC64) check_symbol_exists(__powerpc64le__ "" __PPC64LE) check_symbol_exists(__riscv "" __RISCV) check_symbol_exists(__s390x__ "" __S390X) check_symbol_exists(__wasm32__ "" __WEBASSEMBLY32) check_symbol_exists(__wasm64__ "" __WEBASSEMBLY64) if(__ARM) add_default_target_arch(arm) elseif(__AARCH64) add_default_target_arch(aarch64) elseif(__X86_64) add_default_target_arch(x86_64) elseif(__I386) add_default_target_arch(i386) elseif(__MIPS64) # must be checked before __MIPS add_default_target_arch(mips64) elseif(__MIPS) add_default_target_arch(mips) elseif(__PPC64) add_default_target_arch(powerpc64) elseif(__PPC64LE) add_default_target_arch(powerpc64le) elseif(__RISCV) if(CMAKE_SIZEOF_VOID_P EQUAL "4") add_default_target_arch(riscv32) elseif(CMAKE_SIZEOF_VOID_P EQUAL "8") add_default_target_arch(riscv64) else() message(FATAL_ERROR "Unsupport XLEN for RISC-V") endif() elseif(__S390X) add_default_target_arch(s390x) elseif(__WEBASSEMBLY32) add_default_target_arch(wasm32) elseif(__WEBASSEMBLY64) add_default_target_arch(wasm64) endif() endmacro() macro(load_llvm_config) if (NOT LLVM_CONFIG_PATH) find_program(LLVM_CONFIG_PATH "llvm-config" DOC "Path to llvm-config binary") if (NOT LLVM_CONFIG_PATH) message(FATAL_ERROR "llvm-config not found: specify LLVM_CONFIG_PATH") endif() endif() execute_process( COMMAND ${LLVM_CONFIG_PATH} "--obj-root" "--bindir" "--libdir" "--src-root" RESULT_VARIABLE HAD_ERROR OUTPUT_VARIABLE CONFIG_OUTPUT) if (HAD_ERROR) message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}") endif() string(REGEX REPLACE "[ \t]*[\r\n]+[ \t]*" ";" CONFIG_OUTPUT ${CONFIG_OUTPUT}) list(GET CONFIG_OUTPUT 0 BINARY_DIR) list(GET CONFIG_OUTPUT 1 TOOLS_BINARY_DIR) list(GET CONFIG_OUTPUT 2 LIBRARY_DIR) list(GET CONFIG_OUTPUT 3 MAIN_SRC_DIR) set(LLVM_BINARY_DIR ${BINARY_DIR} CACHE PATH "Path to LLVM build tree") set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin") set(LLVM_LIBRARY_DIR ${LIBRARY_DIR} CACHE PATH "Path to llvm/lib") set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree") # Make use of LLVM CMake modules. # --cmakedir is supported since llvm r291218 (4.0 release) execute_process( COMMAND ${LLVM_CONFIG_PATH} --cmakedir RESULT_VARIABLE HAD_ERROR OUTPUT_VARIABLE CONFIG_OUTPUT) if(NOT HAD_ERROR) string(STRIP "${CONFIG_OUTPUT}" LLVM_CMAKE_PATH_FROM_LLVM_CONFIG) file(TO_CMAKE_PATH ${LLVM_CMAKE_PATH_FROM_LLVM_CONFIG} LLVM_CMAKE_PATH) else() file(TO_CMAKE_PATH ${LLVM_BINARY_DIR} LLVM_BINARY_DIR_CMAKE_STYLE) set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR_CMAKE_STYLE}/lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm") endif() list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}") # Get some LLVM variables from LLVMConfig. include("${LLVM_CMAKE_PATH}/LLVMConfig.cmake") set(LLVM_LIBRARY_OUTPUT_INTDIR ${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX}) endmacro() macro(construct_compiler_rt_default_triple) if(COMPILER_RT_DEFAULT_TARGET_ONLY) if(DEFINED COMPILER_RT_DEFAULT_TARGET_TRIPLE) message(FATAL_ERROR "COMPILER_RT_DEFAULT_TARGET_TRIPLE isn't supported when building for default target only") endif() set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${CMAKE_C_COMPILER_TARGET}) else() set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${TARGET_TRIPLE} CACHE STRING "Default triple for which compiler-rt runtimes will be built.") endif() if(DEFINED COMPILER_RT_TEST_TARGET_TRIPLE) # Backwards compatibility: this variable used to be called # COMPILER_RT_TEST_TARGET_TRIPLE. set(COMPILER_RT_DEFAULT_TARGET_TRIPLE ${COMPILER_RT_TEST_TARGET_TRIPLE}) endif() string(REPLACE "-" ";" TARGET_TRIPLE_LIST ${COMPILER_RT_DEFAULT_TARGET_TRIPLE}) list(GET TARGET_TRIPLE_LIST 0 COMPILER_RT_DEFAULT_TARGET_ARCH) list(GET TARGET_TRIPLE_LIST 1 COMPILER_RT_DEFAULT_TARGET_OS) list(LENGTH TARGET_TRIPLE_LIST TARGET_TRIPLE_LIST_LENGTH) if(TARGET_TRIPLE_LIST_LENGTH GREATER 2) list(GET TARGET_TRIPLE_LIST 2 COMPILER_RT_DEFAULT_TARGET_ABI) endif() # Determine if test target triple is specified explicitly, and doesn't match the # default. if(NOT COMPILER_RT_DEFAULT_TARGET_TRIPLE STREQUAL TARGET_TRIPLE) set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE TRUE) else() set(COMPILER_RT_HAS_EXPLICIT_DEFAULT_TARGET_TRIPLE FALSE) endif() endmacro() # Filter out generic versions of routines that are re-implemented in # architecture specific manner. This prevents multiple definitions of the # same symbols, making the symbol selection non-deterministic. function(filter_builtin_sources output_var exclude_or_include excluded_list) if(exclude_or_include STREQUAL "EXCLUDE") set(filter_action GREATER) set(filter_value -1) elseif(exclude_or_include STREQUAL "INCLUDE") set(filter_action LESS) set(filter_value 0) else() message(FATAL_ERROR "filter_builtin_sources called without EXCLUDE|INCLUDE") endif() set(intermediate ${ARGN}) foreach (_file ${intermediate}) get_filename_component(_name_we ${_file} NAME_WE) list(FIND ${excluded_list} ${_name_we} _found) if(_found ${filter_action} ${filter_value}) list(REMOVE_ITEM intermediate ${_file}) elseif(${_file} MATCHES ".*/.*\\.S" OR ${_file} MATCHES ".*/.*\\.c") get_filename_component(_name ${_file} NAME) string(REPLACE ".S" ".c" _cname "${_name}") list(REMOVE_ITEM intermediate ${_cname}) endif () endforeach () set(${output_var} ${intermediate} PARENT_SCOPE) endfunction() function(get_compiler_rt_target arch variable) if(ANDROID AND ${arch} STREQUAL "i386") set(target "i686${COMPILER_RT_OS_SUFFIX}-${COMPILER_RT_DEFAULT_TARGET_OS}") else() set(target "${arch}-${COMPILER_RT_DEFAULT_TARGET_OS}") endif() if(COMPILER_RT_DEFAULT_TARGET_ABI) set(target "${target}-${COMPILER_RT_DEFAULT_TARGET_ABI}") endif() set(${variable} ${target} PARENT_SCOPE) endfunction() function(get_compiler_rt_install_dir arch install_dir) if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE) get_compiler_rt_target(${arch} target) set(${install_dir} ${COMPILER_RT_INSTALL_PATH}/${target}/lib PARENT_SCOPE) else() set(${install_dir} ${COMPILER_RT_LIBRARY_INSTALL_DIR} PARENT_SCOPE) endif() endfunction() function(get_compiler_rt_output_dir arch output_dir) if(LLVM_ENABLE_PER_TARGET_RUNTIME_DIR AND NOT APPLE) get_compiler_rt_target(${arch} target) set(${output_dir} ${COMPILER_RT_OUTPUT_DIR}/${target}/lib PARENT_SCOPE) else() set(${output_dir} ${COMPILER_RT_LIBRARY_OUTPUT_DIR} PARENT_SCOPE) endif() endfunction() # compiler_rt_process_sources( # # ... # [ADDITIONAL_HEADERS
...] # ) # # Process the provided sources and write the list of new sources # into ``. # # ADDITIONAL_HEADERS - Adds the supplied header to list of sources for IDEs. # # This function is very similar to `llvm_process_sources()` but exists here # because we need to support standalone builds of compiler-rt. function(compiler_rt_process_sources OUTPUT_VAR) cmake_parse_arguments( ARG "" "" "ADDITIONAL_HEADERS" ${ARGN} ) set(sources ${ARG_UNPARSED_ARGUMENTS}) set(headers "") if (XCODE OR MSVC_IDE OR CMAKE_EXTRA_GENERATOR) # For IDEs we need to tell CMake about header files. # Otherwise they won't show up in UI. set(headers ${ARG_ADDITIONAL_HEADERS}) list(LENGTH headers headers_length) if (${headers_length} GREATER 0) set_source_files_properties(${headers} PROPERTIES HEADER_FILE_ONLY ON) endif() endif() set("${OUTPUT_VAR}" ${sources} ${headers} PARENT_SCOPE) endfunction() ================================================ FILE: runtime/cmake/CustomLibcxx/CMakeLists.txt ================================================ cmake_minimum_required(VERSION 3.4.3) project(custom-libcxx C CXX) message(STATUS "COMPILER_RT_LIBCXX_PATH = ${COMPILER_RT_LIBCXX_PATH}") # Build static libcxxabi. set(LIBCXXABI_STANDALONE_BUILD 1) set(LIBCXXABI_ENABLE_SHARED OFF CACHE BOOL "") set(LIBCXXABI_ENABLE_EXCEPTIONS ON CACHE BOOL "") set(LIBCXXABI_HERMETIC_STATIC_LIBRARY ON CACHE STRING "") set(LIBCXXABI_LIBCXX_PATH ${COMPILER_RT_LIBCXX_PATH} CACHE PATH "") set(LIBCXXABI_INCLUDE_TESTS OFF CACHE BOOL "") add_subdirectory(${COMPILER_RT_LIBCXXABI_PATH} ${CMAKE_CURRENT_BINARY_DIR}/cxxabi) # Build static libcxx without exceptions. set(LIBCXX_STANDALONE_BUILD 1) set(LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY OFF CACHE BOOL "") set(LIBCXX_ENABLE_SHARED OFF CACHE BOOL "") set(LIBCXX_ENABLE_EXCEPTIONS ON CACHE BOOL "") set(LIBCXX_HERMETIC_STATIC_LIBRARY ON CACHE BOOL "") # Use above libcxxabi. set(LIBCXX_CXX_ABI "libcxxabi" CACHE STRING "") set(LIBCXX_CXX_ABI_INTREE 1) set(LIBCXX_ENABLE_STATIC_ABI_LIBRARY ON CACHE BOOL "") set(LIBCXX_CXX_ABI_INCLUDE_PATHS ${COMPILER_RT_LIBCXXABI_PATH}/include CACHE PATH "") add_subdirectory(${COMPILER_RT_LIBCXX_PATH} ${CMAKE_CURRENT_BINARY_DIR}/cxx) ================================================ FILE: runtime/cmake/HandleCompilerRT.cmake ================================================ function(find_compiler_rt_library name dest) set(dest "" PARENT_SCOPE) set(CLANG_COMMAND ${CMAKE_CXX_COMPILER} ${SANITIZER_COMMON_CFLAGS} "--rtlib=compiler-rt" "--print-libgcc-file-name") if (CMAKE_CXX_COMPILER_ID MATCHES Clang AND CMAKE_CXX_COMPILER_TARGET) list(APPEND CLANG_COMMAND "--target=${CMAKE_CXX_COMPILER_TARGET}") endif() execute_process( COMMAND ${CLANG_COMMAND} RESULT_VARIABLE HAD_ERROR OUTPUT_VARIABLE LIBRARY_FILE ) string(STRIP "${LIBRARY_FILE}" LIBRARY_FILE) string(REPLACE "builtins" "${name}" LIBRARY_FILE "${LIBRARY_FILE}") if (NOT HAD_ERROR AND EXISTS "${LIBRARY_FILE}") message(STATUS "Found compiler-rt ${name} library: ${LIBRARY_FILE}") set(${dest} "${LIBRARY_FILE}" PARENT_SCOPE) else() message(STATUS "Failed to find compiler-rt ${name} library") endif() endfunction() ================================================ FILE: runtime/cmake/SanitizerUtils.cmake ================================================ include(CompilerRTUtils) set(SANITIZER_GEN_DYNAMIC_LIST ${COMPILER_RT_SOURCE_DIR}/sanitizer_common/scripts/gen_dynamic_list.py) set(SANITIZER_LINT_SCRIPT ${COMPILER_RT_SOURCE_DIR}/sanitizer_common/scripts/check_lint.sh) if(CMAKE_NM) set(SANITIZER_NM "${CMAKE_NM}") else() set(SANITIZER_NM nm) endif() # Create a target "--symbols" that would generate the list of # symbols that need to be exported from sanitizer runtime "". Function # interceptors are exported automatically, user can also provide files with # symbol names that should be exported as well. # add_sanitizer_rt_symbols( # ARCHS # PARENT_TARGET # EXTRA ) macro(add_sanitizer_rt_symbols name) cmake_parse_arguments(ARG "" "PARENT_TARGET" "ARCHS;EXTRA" ${ARGN}) foreach(arch ${ARG_ARCHS}) set(target_name ${name}-${arch}) set(stamp ${CMAKE_CURRENT_BINARY_DIR}/${target_name}.syms-stamp) set(extra_args) foreach(arg ${ARG_EXTRA}) list(APPEND extra_args "--extra" ${arg}) endforeach() add_custom_command(OUTPUT ${stamp} COMMAND ${Python3_EXECUTABLE} ${SANITIZER_GEN_DYNAMIC_LIST} ${extra_args} $ --nm-executable "${SANITIZER_NM}" -o $.syms COMMAND ${CMAKE_COMMAND} -E touch ${stamp} DEPENDS ${target_name} ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMENT "Generating exported symbols for ${target_name}" VERBATIM) add_custom_target(${target_name}-symbols ALL DEPENDS ${stamp} SOURCES ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA}) get_compiler_rt_install_dir(${arch} install_dir) install(FILES $.syms DESTINATION ${install_dir}) if(ARG_PARENT_TARGET) add_dependencies(${ARG_PARENT_TARGET} ${target_name}-symbols) endif() endforeach() endmacro() # This function is only used on Darwin, where undefined symbols must be specified # in the linker invocation. function(add_weak_symbols libname link_flags) set(weak_symbols_file "${COMPILER_RT_SOURCE_DIR}/${libname}/weak_symbols.txt") file(STRINGS "${weak_symbols_file}" WEAK_SYMBOLS) # Add this file as a configure-time dependency so that changes to this # file trigger a re-configure. This is necessary so that `${link_flags}` # is changed when appropriate. set_property( DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${weak_symbols_file}") set(local_link_flags ${${link_flags}}) foreach(SYMBOL ${WEAK_SYMBOLS}) set(local_link_flags ${local_link_flags} -Wl,-U,${SYMBOL}) endforeach() set(${link_flags} ${local_link_flags} PARENT_SCOPE) endfunction() macro(add_sanitizer_rt_version_list name) set(vers ${CMAKE_CURRENT_BINARY_DIR}/${name}.vers) cmake_parse_arguments(ARG "" "" "LIBS;EXTRA" ${ARGN}) set(args) foreach(arg ${ARG_EXTRA}) list(APPEND args "--extra" ${arg}) endforeach() foreach(arg ${ARG_LIBS}) list(APPEND args "$") endforeach() add_custom_command(OUTPUT ${vers} COMMAND ${Python3_EXECUTABLE} ${SANITIZER_GEN_DYNAMIC_LIST} --version-list ${args} --nm-executable "${SANITIZER_NM}" -o ${vers} DEPENDS ${SANITIZER_GEN_DYNAMIC_LIST} ${ARG_EXTRA} ${ARG_LIBS} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMENT "Generating version list for ${name}" VERBATIM) add_custom_target(${name}-version-list ALL DEPENDS ${vers}) endmacro() # Add target to check code style for sanitizer runtimes. if(CMAKE_HOST_UNIX AND NOT OS_NAME MATCHES "OpenBSD") add_custom_target(SanitizerLintCheck COMMAND env LLVM_CHECKOUT=${LLVM_MAIN_SRC_DIR} SILENT=1 TMPDIR= PYTHON_EXECUTABLE=${Python3_EXECUTABLE} COMPILER_RT=${COMPILER_RT_SOURCE_DIR} ${SANITIZER_LINT_SCRIPT} DEPENDS ${SANITIZER_LINT_SCRIPT} COMMENT "Running lint check for sanitizer sources..." VERBATIM) else() add_custom_target(SanitizerLintCheck COMMAND echo "No lint check") endif() set_target_properties(SanitizerLintCheck PROPERTIES FOLDER "Compiler-RT Misc") ================================================ FILE: runtime/common_interface_defs.h ================================================ //===-- sanitizer/common_interface_defs.h -----------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // Common part of the public sanitizer interface. //===----------------------------------------------------------------------===// #ifndef SANITIZER_COMMON_INTERFACE_DEFS_H #define SANITIZER_COMMON_INTERFACE_DEFS_H #include #include // GCC does not understand __has_feature. #if !defined(__has_feature) # define __has_feature(x) 0 #endif #ifdef __cplusplus extern "C" { #endif // Arguments for __sanitizer_sandbox_on_notify() below. typedef struct { // Enable sandbox support in sanitizer coverage. int coverage_sandboxed; // File descriptor to write coverage data to. If -1 is passed, a file will // be pre-opened by __sanitizer_sandobx_on_notify(). This field has no // effect if coverage_sandboxed == 0. intptr_t coverage_fd; // If non-zero, split the coverage data into well-formed blocks. This is // useful when coverage_fd is a socket descriptor. Each block will contain // a header, allowing data from multiple processes to be sent over the same // socket. unsigned int coverage_max_block_size; } __sanitizer_sandbox_arguments; // Tell the tools to write their reports to "path." instead of stderr. void __sanitizer_set_report_path(const char *path); // Tell the tools to write their reports to the provided file descriptor // (casted to void *). void __sanitizer_set_report_fd(void *fd); // Notify the tools that the sandbox is going to be turned on. The reserved // parameter will be used in the future to hold a structure with functions // that the tools may call to bypass the sandbox. void __sanitizer_sandbox_on_notify(__sanitizer_sandbox_arguments *args); // This function is called by the tool when it has just finished reporting // an error. 'error_summary' is a one-line string that summarizes // the error message. This function can be overridden by the client. void __sanitizer_report_error_summary(const char *error_summary); // Some of the sanitizers (e.g. asan/tsan) may miss bugs that happen // in unaligned loads/stores. In order to find such bugs reliably one needs // to replace plain unaligned loads/stores with these calls. uint16_t __sanitizer_unaligned_load16(const void *p); uint32_t __sanitizer_unaligned_load32(const void *p); uint64_t __sanitizer_unaligned_load64(const void *p); void __sanitizer_unaligned_store16(void *p, uint16_t x); void __sanitizer_unaligned_store32(void *p, uint32_t x); void __sanitizer_unaligned_store64(void *p, uint64_t x); // Annotate the current state of a contiguous container, such as // std::vector, std::string or similar. // A contiguous container is a container that keeps all of its elements // in a contiguous region of memory. The container owns the region of memory // [beg, end); the memory [beg, mid) is used to store the current elements // and the memory [mid, end) is reserved for future elements; // beg <= mid <= end. For example, in "std::vector<> v" // beg = &v[0]; // end = beg + v.capacity() * sizeof(v[0]); // mid = beg + v.size() * sizeof(v[0]); // // This annotation tells the Sanitizer tool about the current state of the // container so that the tool can report errors when memory from [mid, end) // is accessed. Insert this annotation into methods like push_back/pop_back. // Supply the old and the new values of mid (old_mid/new_mid). // In the initial state mid == end and so should be the final // state when the container is destroyed or when it reallocates the storage. // // Use with caution and don't use for anything other than vector-like classes. // // For AddressSanitizer, 'beg' should be 8-aligned and 'end' should // be either 8-aligned or it should point to the end of a separate heap-, // stack-, or global- allocated buffer. I.e. the following will not work: // int64_t x[2]; // 16 bytes, 8-aligned. // char *beg = (char *)&x[0]; // char *end = beg + 12; // Not 8 aligned, not the end of the buffer. // This however will work fine: // int32_t x[3]; // 12 bytes, but 8-aligned under AddressSanitizer. // char *beg = (char*)&x[0]; // char *end = beg + 12; // Not 8-aligned, but is the end of the buffer. void __sanitizer_annotate_contiguous_container(const void *beg, const void *end, const void *old_mid, const void *new_mid); // Returns true if the contiguous container [beg, end) is properly poisoned // (e.g. with __sanitizer_annotate_contiguous_container), i.e. if // - [beg, mid) is addressable, // - [mid, end) is unaddressable. // Full verification requires O(end-beg) time; this function tries to avoid // such complexity by touching only parts of the container around beg/mid/end. int __sanitizer_verify_contiguous_container(const void *beg, const void *mid, const void *end); // Similar to __sanitizer_verify_contiguous_container but returns the address // of the first improperly poisoned byte otherwise. Returns null if the area // is poisoned properly. const void *__sanitizer_contiguous_container_find_bad_address( const void *beg, const void *mid, const void *end); // Print the stack trace leading to this call. Useful for debugging user code. void __sanitizer_print_stack_trace(); // Symbolizes the supplied 'pc' using the format string 'fmt'. // Outputs at most 'out_buf_size' bytes into 'out_buf'. // The format syntax is described in // lib/sanitizer_common/sanitizer_stacktrace_printer.h. void __sanitizer_symbolize_pc(void *pc, const char *fmt, char *out_buf, size_t out_buf_size); // Same as __sanitizer_symbolize_pc, but for data section (i.e. globals). void __sanitizer_symbolize_global(void *data_ptr, const char *fmt, char *out_buf, size_t out_buf_size); // Sets the callback to be called right before death on error. // Passing 0 will unset the callback. void __sanitizer_set_death_callback(void (*callback)(void)); // Interceptor hooks. // Whenever a libc function interceptor is called it checks if the // corresponding weak hook is defined, and it so -- calls it. // The primary use case is data-flow-guided fuzzing, where the fuzzer needs // to know what is being passed to libc functions, e.g. memcmp. // FIXME: implement more hooks. void __sanitizer_weak_hook_memcmp(void *called_pc, const void *s1, const void *s2, size_t n, int result); void __sanitizer_weak_hook_strncmp(void *called_pc, const char *s1, const char *s2, size_t n, int result); void __sanitizer_weak_hook_strncasecmp(void *called_pc, const char *s1, const char *s2, size_t n, int result); void __sanitizer_weak_hook_strcmp(void *called_pc, const char *s1, const char *s2, int result); void __sanitizer_weak_hook_strcasecmp(void *called_pc, const char *s1, const char *s2, int result); void __sanitizer_weak_hook_strstr(void *called_pc, const char *s1, const char *s2, char *result); void __sanitizer_weak_hook_strcasestr(void *called_pc, const char *s1, const char *s2, char *result); void __sanitizer_weak_hook_memmem(void *called_pc, const void *s1, size_t len1, const void *s2, size_t len2, void *result); // Prints stack traces for all live heap allocations ordered by total // allocation size until `top_percent` of total live heap is shown. // `top_percent` should be between 1 and 100. // Experimental feature currently available only with asan on Linux/x86_64. void __sanitizer_print_memory_profile(size_t top_percent); // Fiber annotation interface. // Before switching to a different stack, one must call // __sanitizer_start_switch_fiber with a pointer to the bottom of the // destination stack and its size. When code starts running on the new stack, // it must call __sanitizer_finish_switch_fiber to finalize the switch. // The start_switch function takes a void** to store the current fake stack if // there is one (it is needed when detect_stack_use_after_return is enabled). // When restoring a stack, this pointer must be given to the finish_switch // function. In most cases, this void* can be stored on the stack just before // switching. When leaving a fiber definitely, null must be passed as first // argument to the start_switch function so that the fake stack is destroyed. // If you do not want support for stack use-after-return detection, you can // always pass null to these two functions. // Note that the fake stack mechanism is disabled during fiber switch, so if a // signal callback runs during the switch, it will not benefit from the stack // use-after-return detection. void __sanitizer_start_switch_fiber(void **fake_stack_save, const void *bottom, size_t size); void __sanitizer_finish_switch_fiber(void *fake_stack_save, const void **bottom_old, size_t *size_old); #ifdef __cplusplus } // extern "C" #endif #endif // SANITIZER_COMMON_INTERFACE_DEFS_H ================================================ FILE: runtime/dfsan/.clang-format ================================================ BasedOnStyle: Google AllowShortIfStatementsOnASingleLine: false IndentPPDirectives: AfterHash ================================================ FILE: runtime/dfsan/CMakeLists.txt ================================================ # include_directories(..) # Runtime library sources and build flags. set(DFSAN_RTL_SOURCES dfsan.cpp dfsan_custom.cpp dfsan_interceptors.cpp taint_allocator.cpp union_util.cpp union_hashtable.cpp) set(DFSAN_RTL_HEADERS dfsan.h dfsan_flags.inc dfsan_platform.h taint_allocator.h union_util.h union_hashtable.h) set(DFSAN_COMMON_CFLAGS ${SANITIZER_COMMON_CFLAGS}) if(OS_NAME MATCHES "Linux" AND COMPILER_RT_LIBCXX_PATH AND COMPILER_RT_LIBCXXABI_PATH) list(APPEND DFSAN_COMMON_CFLAGS -nostdinc++ -D_LIBCPP_ABI_VERSION=Taint) # Remove -stdlib= which is unused when passing -nostdinc++. string(REGEX REPLACE "-stdlib=[a-zA-Z+]*" "" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS}) endif() append_rtti_flag(OFF DFSAN_COMMON_CFLAGS) # Prevent clang from generating libc calls. append_list_if(COMPILER_RT_HAS_FFREESTANDING_FLAG -ffreestanding DFSAN_COMMON_CFLAGS) # Static runtime library. add_compiler_rt_component(dfsan) foreach(arch ${DFSAN_SUPPORTED_ARCH}) set(DFSAN_CFLAGS ${DFSAN_COMMON_CFLAGS}) append_list_if(COMPILER_RT_HAS_FPIE_FLAG -fPIE DFSAN_CFLAGS) add_compiler_rt_runtime(dfsan_rt STATIC ARCHS ${arch} SOURCES ${DFSAN_RTL_SOURCES} $ $ $ $ ADDITIONAL_HEADERS ${DFSAN_RTL_HEADERS} CFLAGS ${DFSAN_CFLAGS} PARENT_TARGET dfsan) add_sanitizer_rt_symbols(dfsan_rt ARCHS ${arch} EXTRA dfsan.syms.extra) add_dependencies(dfsan dfsan_rt-${arch}-symbols) if(OS_NAME MATCHES "Linux" AND COMPILER_RT_LIBCXX_PATH AND COMPILER_RT_LIBCXXABI_PATH) macro(partially_link_libcxx name dir arch) set(cxx_${arch}_merge_dir "${CMAKE_CURRENT_BINARY_DIR}/cxx_${arch}_merge.dir") file(MAKE_DIRECTORY ${cxx_${arch}_merge_dir}) add_custom_command(TARGET dfsan_rt-${arch} POST_BUILD COMMAND ${CMAKE_LINKER} --whole-archive "$" --no-whole-archive ${dir}/lib/libc++.a --no-whole-archive ${dir}/lib/libc++abi.a -r -o ${name}.o COMMAND ${CMAKE_OBJCOPY} --localize-hidden ${name}.o COMMAND ${CMAKE_COMMAND} -E remove "$" COMMAND ${CMAKE_AR} qcs "$" ${name}.o WORKING_DIRECTORY ${cxx_${arch}_merge_dir} ) endmacro() set(TARGET_CFLAGS ${TARGET_${arch}_CFLAGS} PARENT_SCOPE) set(LIBCXX_${arch}_PREFIX ${CMAKE_CURRENT_BINARY_DIR}/libcxx_taint_${arch}) add_custom_libcxx(libcxx_taint_${arch} ${LIBCXX_${arch}_PREFIX} CFLAGS ${TARGET_CFLAGS} -D_LIBCPP_ABI_VERSION=Taint -D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS=1 -fvisibility=hidden CMAKE_ARGS -DCMAKE_CXX_COMPILER_WORKS=ON -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DLIBCXX_ENABLE_EXCEPTIONS=ON -DLIBCXX_ABI_NAMESPACE=__Taint) target_compile_options(dfsan_rt-${arch} PRIVATE -isystem ${LIBCXX_${arch}_PREFIX}/include/c++/v1) add_dependencies(dfsan_rt-${arch} libcxx_taint_${arch}-build) partially_link_libcxx(taint ${LIBCXX_${arch}_PREFIX} ${arch}) endif() install(FILES ${COMPILER_RT_OUTPUT_DIR}/libdfsan_rt-${arch}.a.syms DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}) endforeach() set(dfsan_abilist_dir ${COMPILER_RT_OUTPUT_DIR}/share) set(dfsan_abilist_filename ${dfsan_abilist_dir}/dfsan_abilist.txt) add_custom_target(dfsan_abilist ALL DEPENDS ${dfsan_abilist_filename}) add_custom_command(OUTPUT ${dfsan_abilist_filename} VERBATIM COMMAND ${CMAKE_COMMAND} -E make_directory ${dfsan_abilist_dir} COMMAND cat ${CMAKE_CURRENT_SOURCE_DIR}/done_abilist.txt ${CMAKE_CURRENT_SOURCE_DIR}/libc_ubuntu2404_abilist.txt > ${dfsan_abilist_filename} DEPENDS done_abilist.txt libc_ubuntu2404_abilist.txt) add_dependencies(dfsan dfsan_abilist) install(FILES ${dfsan_abilist_filename} DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}) install(FILES "libc++_abilist.txt" DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}) set(taint_linker_script_filename ${COMPILER_RT_OUTPUT_DIR}/taint.ld) add_custom_target(taint_linker_script ALL DEPENDS ${taint_linker_script_filename}) add_custom_command(OUTPUT ${taint_linker_script_filename} VERBATIM COMMAND cat ${CMAKE_CURRENT_SOURCE_DIR}/taint.ld > ${taint_linker_script_filename} DEPENDS taint.ld) add_dependencies(dfsan taint_linker_script) install(FILES ${taint_linker_script_filename} DESTINATION ${COMPILER_RT_LIBRARY_INSTALL_DIR}) ================================================ FILE: runtime/dfsan/dfsan.cpp ================================================ //===-- dfsan.cc ----------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of DataFlowSanitizer. // // DataFlowSanitizer runtime. This file defines the public interface to // DataFlowSanitizer as well as the definition of certain runtime functions // called automatically by the compiler (specifically the instrumentation pass // in llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp). // // The public interface is defined in include/sanitizer/dfsan_interface.h whose // functions are prefixed dfsan_ while the compiler interface functions are // prefixed __dfsan_. //===----------------------------------------------------------------------===// #include "sanitizer_common/sanitizer_atomic.h" #include "sanitizer_common/sanitizer_allocator_internal.h" #include "sanitizer_common/sanitizer_common.h" #include "sanitizer_common/sanitizer_file.h" #include "sanitizer_common/sanitizer_flags.h" #include "sanitizer_common/sanitizer_flag_parser.h" #include "sanitizer_common/sanitizer_libc.h" #include "sanitizer_common/sanitizer_mutex.h" #include "sanitizer_common/sanitizer_posix.h" #include "dfsan.h" #include "taint_allocator.h" #include "union_util.h" #include "union_hashtable.h" #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace __dfsan; typedef atomic_uint32_t atomic_dfsan_label; static atomic_dfsan_label __dfsan_last_label; static dfsan_label_info *__dfsan_label_info; // FIXME: single thread // statck bottom static dfsan_label __alloca_stack_bottom; static dfsan_label __alloca_stack_top; static const int MAX_SAVED_STACK_ENTRIES = 1024; static dfsan_label __saved_alloca_stack_top[MAX_SAVED_STACK_ENTRIES]; static int __current_saved_stack_index = 0; // taint source struct taint_file __dfsan::tainted; struct taint_socket __dfsan::tainted_socket; // Hash table static const uptr hashtable_size = (1ULL << 32); static const size_t hashtable_buckets = (1ULL << 20); static __taint::union_hashtable __union_table(hashtable_buckets); Flags __dfsan::flags_data; bool print_debug; // The size of TLS variables. These constants must be kept in sync with the ones // in Taint.cc static const int kArgTlsSize = 800; static const int kRetvalTlsSize = 800; SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL uint64_t __dfsan_retval_tls[kRetvalTlsSize / sizeof(uint64_t)]; SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL uint64_t __dfsan_arg_tls[kArgTlsSize / sizeof(uint64_t)]; SANITIZER_INTERFACE_ATTRIBUTE uptr __dfsan_shadow_ptr_mask; // On Linux/x86_64, memory is laid out as follows: // // +--------------------+ 0x800000000000 (top of memory) // | application memory | // +--------------------+ 0x700000040000 (kAppAddr) // |--------------------| UnusedAddr() // | | // | union table | // | | // +--------------------+ 0x400100000000 (kUnionTableAddr) // | hash table | // +--------------------+ 0x400000000000 (kHashTableAddr) // | shadow memory | // +--------------------+ 0x000000100000 (kShadowAddr) // | unused | // +--------------------+ 0x000000010000 (kKernelAddr) // | reserved by kernel | // +--------------------+ 0x000000000000 // // To derive a shadow memory address from an application memory address, // bits 44-46 are cleared to bring the address into the range // [0x000000040000,0x100000000000). Then the address is shifted left by 2 to // account for the double byte representation of shadow labels and move the // address into the shadow memory range. See the function shadow_for below. #ifdef DFSAN_RUNTIME_VMA // Runtime detected VMA size. int __dfsan::vmaSize; #endif static uptr UnusedAddr() { return MappingArchImpl() + uniontable_size; } // Checks we do not run out of labels. static void dfsan_check_label(dfsan_label label) { if (label == kInitializingLabel) { Report("FATAL: Taint: out of labels\n"); Die(); } // Alloca labels are in range [__alloca_stack_top, __alloca_stack_bottom] if (label >= __alloca_stack_top && label <= __alloca_stack_bottom) { return; // Valid Alloca label } // For regular labels, check against __dfsan_last_label dfsan_label last = atomic_load(&__dfsan_last_label, memory_order_relaxed); if (label > last) { Report("FATAL: Invalid label %u > last %u\n", label, last); Die(); } } // based on https://github.com/Cyan4973/xxHash // simplified since we only have 12 bytes info static inline uint32_t xxhash(uint32_t h1, uint32_t h2, uint32_t h3) { const uint32_t PRIME32_1 = 2654435761U; const uint32_t PRIME32_2 = 2246822519U; const uint32_t PRIME32_3 = 3266489917U; const uint32_t PRIME32_4 = 668265263U; const uint32_t PRIME32_5 = 374761393U; #define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r))) uint32_t h32 = PRIME32_5; h32 += h1 * PRIME32_3; h32 = XXH_rotl32(h32, 17) * PRIME32_4; h32 += h2 * PRIME32_3; h32 = XXH_rotl32(h32, 17) * PRIME32_4; h32 += h3 * PRIME32_3; h32 = XXH_rotl32(h32, 17) * PRIME32_4; #undef XXH_rotl32 h32 ^= h32 >> 15; h32 *= PRIME32_2; h32 ^= h32 >> 13; h32 *= PRIME32_3; h32 ^= h32 >> 16; return h32; } dfsan_label_info* __dfsan::get_label_info(dfsan_label label) { return &__dfsan_label_info[label]; } static inline bool is_constant_label(dfsan_label label) { return label == CONST_LABEL; } static inline bool is_kind_of_label(dfsan_label label, uint16_t kind) { return get_label_info(label)->op == kind; } static bool isZeroOrPowerOfTwo(uint16_t x) { return (x & (x - 1)) == 0; } static inline bool is_valid_op(uint16_t op) { op &= 0xff; return op >= __dfsan::Add && op < __dfsan::LastOp || op == __dfsan::Not; } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_cond(dfsan_label label, bool r, uint8_t flag, uint32_t cid); extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_label __taint_union(dfsan_label l1, dfsan_label l2, uint16_t op, uint16_t size, uint64_t op1, uint64_t op2) { if (!is_valid_op(op)) { AOUT("WARNING: invalid op %d\n", op); return 0; } if (l1 > l2 && is_commutative(op)) { // needs to swap both labels and concretes Swap(l1, l2); Swap(op1, op2); } if (l1 == 0 && l2 < CONST_OFFSET && op != fsize && op != __dfsan::Alloca) return 0; if (l1 == kInitializingLabel || l2 == kInitializingLabel) return kInitializingLabel; // special handling for bounds if (get_label_info(l1)->op == __dfsan::Alloca || (op != __dfsan::Load && get_label_info(l2)->op == __dfsan::Alloca)) { // propagate if it's casting op if (op == __dfsan::BitCast) return l1; if (op == __dfsan::PtrToInt) {AOUT("WARNING: ptrtoint %d\n", l1); return 0;} if ((op & 0xff) == __dfsan::ICmp) { return 0;} // ptr1 op ptr2 if (op != __dfsan::Extract) { AOUT("WARNING: unsupported op %d over ptr1 %d ptr2 %d\n", op, l1, l2); return 0; } } // backup old op-values uint64_t orig_op1 = op1, orig_op2 = op2; // Preserve op1/op2 for certain operations: // - Alloca: uses op1/op2 for bounds tracking // - ICmp: records both operands for comparison // - Higher-order ops (>= fmemcmp): use op1/op2 for various purposes if (op == __dfsan::fmemcmp) { // fmemcmp special: copy up to 8 bytes of the data for i2s inference uint16_t len = size > 8 ? 8 : size; // for fmemcmp, size is in bytes, not bits if (l1 >= CONST_OFFSET) internal_memcpy(&op1, (void*)op1, len); if (l2 >= CONST_OFFSET) internal_memcpy(&op2, (void*)op2, len); } else if (op < __dfsan::fmemcmp && op != __dfsan::Alloca && op != __dfsan::PtrToInt && (op & 0xff) != __dfsan::ICmp) { // Not a higher-order op and not Alloca/ICmp/PtrToInt - zero out for symbolic operands // PtrToInt needs op1 preserved to compute base pointer for string ops if (l1 >= CONST_OFFSET) op1 = 0; if (l2 >= CONST_OFFSET) op2 = 0; } // try simple simplifications, from qsym bool op1_is_zero = (l1 == 0 && op1 == 0); bool op1_is_all_one = (l1 == 0 && op1 == ((uint64_t)1 << size) - 1); bool op2_is_zero = (l2 == 0 && op2 == 0); if (op1_is_zero) { switch (op) { case __dfsan::And: // 0 & x = 0 case __dfsan::Mul: // 0 * x = 0 case __dfsan::Shl: // 0 << x = 0 return 0; case __dfsan::Or: // 0 | x = x case __dfsan::Xor: // 0 ^ x = x case __dfsan::Add: // 0 + x = x return l2; } } else if (op1_is_all_one) { if (op == __dfsan::And) return l2; // 0b11..1 & x = x else if (op == __dfsan::Or) return 0; // 0b11..1 | x = 11..1b else if (op == __dfsan::Xor && size == 1) op = __dfsan::Not; // 0b1 ^ x = !x } if (op2_is_zero) { if (op == __dfsan::Sub) return l1; // x - 0 = x else if (op == __dfsan::Shl) return l1; // x << 0 = x else if (op == __dfsan::LShr) return l1; // x >> 0 = x else if (op == __dfsan::AShr) return l1; // x >> 0 = x } if (op == __dfsan::Trunc) { if (__dfsan_label_info[l1].op == __dfsan::ZExt || __dfsan_label_info[l1].op == __dfsan::SExt) { dfsan_label base = __dfsan_label_info[l1].l1; if (size == __dfsan_label_info[base].size) return base; } } else if (op == __dfsan::Xor && l1 == l2) { // x ^ x = 0 return 0; } // setup a hash tree for dedup uint32_t h1 = l1 ? __dfsan_label_info[l1].hash : 0; uint32_t h2 = l2 ? __dfsan_label_info[l2].hash : 0; uint32_t h3 = op; h3 = (h3 << 16) | size; uint32_t hash = xxhash(h1, h2, h3); struct dfsan_label_info label_info = { .l1 = l1, .l2 = l2, .op1 = {op1}, .op2 = {op2}, .op = op, .size = size, .hash = hash}; __taint::option res = __union_table.lookup(label_info); if (res != __taint::none()) { dfsan_label label = *res; AOUT("%u found\n", label); return label; } // ubsan checks, after dedup, so we don't do redundant checks if (l2 && flags().solve_ub) { dfsan_label cond = 0; uint16_t op_size = get_label_info(l2)->size; switch(op & 0xff) { case __dfsan::Add: case __dfsan::Sub: case __dfsan::Mul: // check for integer overflow break; case __dfsan::UDiv: case __dfsan::SDiv: case __dfsan::URem: case __dfsan::SRem: // check for division by zero // -fsanitize=integer-divide-by-zero if (orig_op2 != 0) { cond = __taint_union(l2, 0, (bveq << 8) | __dfsan::ICmp, size, orig_op2, 0); __taint_trace_cond(cond, 0, UndefinedCheck, ub_division_by_zero); } break; case __dfsan::Shl: case __dfsan::LShr: case __dfsan::AShr: // -fsanitize=shift-exponent // check for too large value: exponent > size if (orig_op2 < size) { cond = __taint_union(l2, 0, (bvuge << 8) | __dfsan::ICmp, op_size, orig_op2, size), __taint_trace_cond(cond, 0, UndefinedCheck, ub_shift_exponent); } if ((int64_t)orig_op2 >= 0) { // check for negative value cond = __taint_union(l2, 0, (bvslt << 8) | __dfsan::ICmp, op_size, orig_op2, 0), __taint_trace_cond(cond, 0, UndefinedCheck, ub_shift_exponent); } if (op == __dfsan::Shl && orig_op1 != 0 && orig_op2 <= __builtin_clzl(orig_op1) - (64 - size)) { // check for shift overflow // op2 > leading zero bits in op1 cond = __taint_union(l2, 0, (bvugt << 8) | __dfsan::ICmp, op_size, orig_op2, __builtin_clzl(orig_op1) - (64 - size)); __taint_trace_cond(cond, 0, UndefinedCheck, ub_shift_overflow); } if (l1 && (int64_t)orig_op1 >= 0) { // check for negative base // -fsanitize=shift-base // op1 < 0 cond = __taint_union(l1, 0, (bvslt << 8) | __dfsan::ICmp, get_label_info(l1)->size, orig_op1, 0); __taint_trace_cond(cond, 0, UndefinedCheck, ub_shift_base); } break; default: break; } } dfsan_label label = atomic_fetch_add(&__dfsan_last_label, 1, memory_order_relaxed) + 1; dfsan_check_label(label); assert(label > l1 && label > l2); AOUT("%u = (%u, %u, %u, %u, %lu, %lu)\n", label, l1, l2, op, size, op1, op2); internal_memcpy(&__dfsan_label_info[label], &label_info, sizeof(dfsan_label_info)); __union_table.insert(&__dfsan_label_info[label], label); if (flags().solve_ub) { if (op == __dfsan::Trunc && l1) { // check for data loss, after the new label is created // -fsanitize=implicit-unsigned-integer-truncation // old_vale >= (1 << new_size) if (orig_op1 < (1UL << size)) { // if current value does not have loss dfsan_label loss = __taint_union(l1, 0, (bvuge << 8) | __dfsan::ICmp, get_label_info(l1)->size, orig_op1, 1UL << size); __taint_trace_cond(loss, 0, UndefinedCheck, ub_unsigned_integer_truncation); } // -fsanitize=implicit-signed-integer-truncation // old_value < signed(1 << (size - 1)) int64_t target = (int64_t)((0xFFFFFFFFFFFFFFFFUL >> (size-1)) << (size-1)); if ((int64_t)orig_op1 >= target) { uint16_t old_size = get_label_info(l1)->size; if (old_size < 64) target &= ~(1UL << old_size); dfsan_label loss = __taint_union(l1, 0, (bvslt << 8) | __dfsan::ICmp, old_size, orig_op1, target); __taint_trace_cond(loss, 0, UndefinedCheck, ub_signed_integer_truncation); } // -fsanitize=implicit-integer-sign-change // Check if sign bit changed during truncation { uint16_t src_size = get_label_info(l1)->size; const uint64_t new_mask = size == 64 ? 0xFFFFFFFFFFFFFFFFUL : (1UL << size) - 1; uint64_t src_sign_bit = 1ULL << (src_size - 1); uint64_t dst_sign_bit = 1ULL << (size - 1); bool src_sign = (orig_op1 & src_sign_bit) != 0; bool dst_sign = ((orig_op1 & new_mask) & dst_sign_bit) != 0; if (src_sign == dst_sign) { // Currently no sign change, check if it can happen // Sign changes when: sign_bit(l1) != sign_bit(label) // We check: (l1 < 0) XOR (label < 0) dfsan_label src_neg = __taint_union(l1, 0, (bvslt << 8) | __dfsan::ICmp, src_size, orig_op1, 0); dfsan_label dst_neg = __taint_union(label, 0, (bvslt << 8) | __dfsan::ICmp, size, orig_op1 & new_mask, 0); dfsan_label sign_diff = __taint_union(src_neg, dst_neg, __dfsan::Xor, 1, src_sign ? 1 : 0, dst_sign ? 1 : 0); __taint_trace_cond(sign_diff, 0, UndefinedCheck, ub_integer_sign_change); } } } else if (op == __dfsan::Add) { // check for integer overflow // -fsanitize=signed-integer-overflow, unsigned-integer-overflow // // we only care about l2, which is always symbolic const uint64_t mask = size == 64 ? 0xFFFFFFFFFFFFFFFFUL : (1UL << size) - 1; uint64_t result = (orig_op1 + orig_op2) & mask; // Signed overflow detection: // Overflow occurs when ((op1 ^ result) & (op2 ^ result)) has sign bit set // This means both operands had same sign, but result has different sign uint64_t xor1 = (orig_op1 ^ result) & mask; uint64_t xor2 = (orig_op2 ^ result) & mask; uint64_t overflow_check = xor1 & xor2; uint64_t sign_bit = 1ULL << (size - 1); bool has_signed_overflow = (overflow_check & sign_bit) != 0; if (!has_signed_overflow) { // Build symbolic expression: ((l1 ^ label) & (l2 ^ label)) < 0 dfsan_label xor_l1 = __taint_union(l1, label, __dfsan::Xor, size, orig_op1, result); dfsan_label xor_l2 = __taint_union(l2, label, __dfsan::Xor, size, orig_op2, result); dfsan_label and_xors = __taint_union(xor_l1, xor_l2, __dfsan::And, size, xor1, xor2); dfsan_label cond = __taint_union(and_xors, 0, (bvslt << 8) | __dfsan::ICmp, size, overflow_check, 0); __taint_trace_cond(cond, 0, UndefinedCheck, ub_integer_overflow); } // Unsigned overflow: result < op1 (for any non-zero op2) // When adding two unsigned numbers, overflow means result wrapped around if (result >= orig_op1 && orig_op2 != 0) { dfsan_label cond = __taint_union(label, l1, (bvult << 8) | __dfsan::ICmp, size, result, orig_op1); __taint_trace_cond(cond, 0, UndefinedCheck, ub_integer_overflow); } } else if (op == __dfsan::Mul) { // check for integer overflow // we only care about l2, which is always symbolic const uint64_t mask = size == 64 ? 0xFFFFFFFFFFFFFFFFUL : (1UL << size) - 1; uint64_t result = (orig_op1 * orig_op2) & mask; // For multiplication, overflow is harder to detect symbolically // Use the approach: if a != 0, then overflow iff result / a != b // But we approximate with sign-based check similar to addition uint64_t xor1 = (orig_op1 ^ result) & mask; uint64_t xor2 = (orig_op2 ^ result) & mask; uint64_t overflow_check = xor1 & xor2; uint64_t sign_bit = 1ULL << (size - 1); // For signed multiplication: check if signs are inconsistent // Product of same signs should be positive, different signs should be negative // This is an approximation - full check would need wider multiplication bool has_signed_overflow = (overflow_check & sign_bit) != 0; if (!has_signed_overflow && orig_op1 != 0 && orig_op2 != 0) { dfsan_label xor_l1 = __taint_union(l1, label, __dfsan::Xor, size, orig_op1, result); dfsan_label xor_l2 = __taint_union(l2, label, __dfsan::Xor, size, orig_op2, result); dfsan_label and_xors = __taint_union(xor_l1, xor_l2, __dfsan::And, size, xor1, xor2); dfsan_label cond = __taint_union(and_xors, 0, (bvslt << 8) | __dfsan::ICmp, size, overflow_check, 0); __taint_trace_cond(cond, 0, UndefinedCheck, ub_integer_overflow); } // Unsigned overflow: for multiplication, check if result / op1 != op2 (when op1 != 0) if (orig_op1 != 0 && result / orig_op1 == orig_op2) { // No overflow currently, check if overflow can happen // Approximate: result < op1 || result < op2 when both > 1 if (orig_op1 > 1 && orig_op2 > 1) { dfsan_label cond = __taint_union(label, l1, (bvult << 8) | __dfsan::ICmp, size, result, orig_op1); __taint_trace_cond(cond, 0, UndefinedCheck, ub_integer_overflow); } } } else if (op == __dfsan::Sub) { // check for integer overflow (underflow for subtraction) // -fsanitize=signed-integer-overflow, unsigned-integer-overflow const uint64_t mask = size == 64 ? 0xFFFFFFFFFFFFFFFFUL : (1UL << size) - 1; uint64_t result = (orig_op1 - orig_op2) & mask; // Signed overflow detection for subtraction: // Overflow occurs when sign(a) != sign(b) and sign(result) != sign(a) // Formula: (a ^ b) & (a ^ result) has sign bit set // Examples: // INT_MAX - (-1) = overflow (positive - negative, result should be more positive but wraps) // INT_MIN - 1 = overflow (negative - positive, result should be more negative but wraps) uint64_t xor_ab = (orig_op1 ^ orig_op2) & mask; uint64_t xor_ar = (orig_op1 ^ result) & mask; uint64_t overflow_check = xor_ab & xor_ar; uint64_t sign_bit = 1ULL << (size - 1); bool has_signed_overflow = (overflow_check & sign_bit) != 0; if (!has_signed_overflow) { // Build symbolic expression: ((l1 ^ l2) & (l1 ^ label)) < 0 dfsan_label xor_l1l2 = __taint_union(l1, l2, __dfsan::Xor, size, orig_op1, orig_op2); dfsan_label xor_l1r = __taint_union(l1, label, __dfsan::Xor, size, orig_op1, result); dfsan_label and_xors = __taint_union(xor_l1l2, xor_l1r, __dfsan::And, size, xor_ab, xor_ar); dfsan_label cond = __taint_union(and_xors, 0, (bvslt << 8) | __dfsan::ICmp, size, overflow_check, 0); __taint_trace_cond(cond, 0, UndefinedCheck, ub_integer_overflow); } // Unsigned underflow: result > op1 when op2 > 0 // When subtracting, if a < b, result wraps around to large value (result > a) if (result <= orig_op1 && orig_op2 != 0) { dfsan_label cond = __taint_union(label, l1, (bvugt << 8) | __dfsan::ICmp, size, result, orig_op1); __taint_trace_cond(cond, 0, UndefinedCheck, ub_integer_overflow); } } } return label; } extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_label __taint_union_load(const dfsan_label *ls, uptr n, uint64_t align) { if ((uptr)ls < 4096) { AOUT("WARNING: nullptr deref\n"); return 0; } else if (((uptr)ls & (align - 1)) != 0) { AOUT("WARNING: unaligned load %p\n", ls); } dfsan_label label0 = ls[0]; if (label0 == kInitializingLabel) return kInitializingLabel; // for debugging // dfsan_label l = atomic_load(&__dfsan_last_label, memory_order_relaxed); // assert(label0 <= l); if (label0 >= CONST_OFFSET) assert(get_label_info(label0)->size != 0); // fast path 1: constant and bounds if (is_constant_label(label0) || is_kind_of_label(label0, Alloca)) { bool same = true; for (uptr i = 1; i < n; i++) { if (ls[i] == kInitializingLabel) return kInitializingLabel; else if (ls[i] != label0) { same = false; break; } } if (same) return label0; } AOUT("label0 = %d, n = %lu, ls = %p\n", label0, n, ls); // shape bool shape = true; if (__dfsan_label_info[label0].op != 0) { // not raw input bytes shape = false; } else { off_t offset = get_label_info(label0)->op1.i; for (uptr i = 1; i != n; ++i) { dfsan_label next_label = ls[i]; if (next_label == kInitializingLabel) return kInitializingLabel; else if (get_label_info(next_label)->op1.i != offset + i) { shape = false; break; } } } if (shape) { if (n == 1) return label0; AOUT("shape: label0: %d %lu\n", label0, n); return __taint_union(label0, (dfsan_label)n, Load, n * 8, 0, 0); } // fast path 2: all labels are extracted from a n-size label, // then return that label if (is_kind_of_label(label0, Extract)) { dfsan_label parent = get_label_info(label0)->l1; uptr offset = 0; for (uptr i = 0; i < n; i++) { dfsan_label next_label = ls[i]; if (next_label == kInitializingLabel) return kInitializingLabel; dfsan_label_info *info = get_label_info(next_label); if (info->op != Extract || offset != info->op2.i || parent != info->l1) { break; } offset += info->size; } if (get_label_info(parent)->size == offset && offset == n * 8) { AOUT("Fast path (2): all labels are extracts: %u\n", parent); return parent; } } // slowpath AOUT("union load slowpath at %p\n", __builtin_return_address(0)); dfsan_label label = label0; for (uptr i = get_label_info(label0)->size / 8; i < n;) { dfsan_label next_label = ls[i]; if (next_label == kInitializingLabel) return kInitializingLabel; uint16_t next_size = get_label_info(next_label)->size; AOUT("next label=%u, size=%u\n", next_label, next_size); if (!is_constant_label(next_label)) { if (next_size <= (n - i) * 8) { i += next_size / 8; label = __taint_union(label, next_label, Concat, i * 8, 0, 0); } else { Report("WARNING: partial loading expected=%lu has=%d\n", n-i, next_size); uptr size = n - i; dfsan_label trunc = __taint_union(next_label, CONST_LABEL, Trunc, size * 8, 0, 0); return __taint_union(label, trunc, Concat, n * 8, 0, 0); } } else { Report("WARNING: taint mixed with concrete %lu\n", i); char *c = (char *)app_for(&ls[i]); ++i; label = __taint_union(label, 0, Concat, i * 8, 0, *c); } } AOUT("\n"); return label; } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_union_store(dfsan_label l, dfsan_label *ls, uptr n, uint64_t align) { //AOUT("label = %d, n = %lu, ls = %p\n", l, n, ls); if ((uptr)ls < 4096) { AOUT("WARNING: nullptr deref\n"); return; } else if (((uptr)ls & (align - 1)) != 0) { AOUT("WARNING: unaligned store %p\n", ls); } if (l != kInitializingLabel) { // for debugging dfsan_label h = atomic_load(&__dfsan_last_label, memory_order_relaxed); assert(l <= __alloca_stack_bottom); if (l > h && l < __alloca_stack_top) { AOUT("WARNING: unallocated label %d > %d, and < %d\n", l, h, __alloca_stack_top); } } else { for (uptr i = 0; i < n; ++i) ls[i] = l; return; } // fast path 1: constant and bounds if (l == 0 || is_kind_of_label(l, Alloca)) { for (uptr i = 0; i < n; ++i) ls[i] = l; return; } dfsan_label_info *info = get_label_info(l); // fast path 2: single byte if (n == 1 && info->size == 8) { ls[0] = l; return; } // fast path 3: load if (is_kind_of_label(l, Load)) { // if source label is union load, just break it up dfsan_label label0 = info->l1; if (n > info->l2) { Report("WARNING: store size=%lu larger than load size=%d\n", n, info->l2); } for (uptr i = 0; i < n; ++i) ls[i] = label0 + i; return; } // default fall through for (uptr i = 0; i < n; ++i) { ls[i] = __taint_union(l, CONST_LABEL, Extract, 8, 0, i * 8); } } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_push_stack_frame() { if (flags().trace_bounds) { if (__current_saved_stack_index < MAX_SAVED_STACK_ENTRIES) __saved_alloca_stack_top[++__current_saved_stack_index] = __alloca_stack_top; } } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_pop_stack_frame() { if (flags().trace_bounds) { __alloca_stack_top = __saved_alloca_stack_top[__current_saved_stack_index--]; } } extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_label __taint_trace_alloca(dfsan_label l, uint64_t size, uint64_t elem_size, uint64_t base) { if (flags().trace_bounds) { __alloca_stack_top -= 1; AOUT("label = %d, base = %p, size = %lu, elem_size = %lu\n", __alloca_stack_top, (void*)base, size, elem_size); dfsan_label_info *info = get_label_info(__alloca_stack_top); internal_memset(info, 0, sizeof(dfsan_label_info)); info->l2 = l; info->op = Alloca; info->size = sizeof(void*) * 8; info->op1.i = base; info->op2.i = base + size * elem_size; // set uninit label dfsan_set_label(kInitializingLabel, (void*)base, size * elem_size); return __alloca_stack_top; } else { return 0; } } extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_label __taint_trace_global(uint64_t addr, uint64_t size) { if (flags().trace_bounds) { // setup a hash tree for dedup uint32_t h1 = (uint32_t)addr; // lower 32 bits uint32_t h2 = (uint32_t)(addr >> 32); // upper 32 bits uint32_t hash = xxhash(h1, h2, Alloca); struct dfsan_label_info label_info = { .l1 = 0, .l2 = 0, .op1 = {addr}, .op2 = {addr + size}, .op = __dfsan::Alloca, .size = sizeof(void*) * 8, .hash = hash}; __taint::option res = __union_table.lookup(label_info); if (res != __taint::none()) { dfsan_label label = *res; AOUT("global %u found\n", label); return label; } dfsan_label label = atomic_fetch_add(&__dfsan_last_label, 1, memory_order_relaxed) + 1; dfsan_check_label(label); internal_memcpy(&__dfsan_label_info[label], &label_info, sizeof(dfsan_label_info)); __union_table.insert(&__dfsan_label_info[label], label); AOUT("adding global bounds %d=(%lx, %lu)\n", label, addr, size); return label; } return 0; } SANITIZER_INTERFACE_WEAK_DEF(void, __taint_trace_memerr, dfsan_label, uptr, dfsan_label, uint64_t, uint16_t, void*) {} // NOTES: for Alloca, or buffer buounds info // .l1 = num of elements label, for calloc style allocators // .l2 = (element) size label // .op1 = lower bounds // .op2 = upper bounds extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_check_bounds(dfsan_label addr_label, uptr addr, dfsan_label size_label, uint64_t size) { if (flags().trace_bounds) { void *retaddr = __builtin_return_address(0); if (addr == 0) { AOUT("WARNING: null ptr deref %p = %d @%p\n", (void*)addr, addr_label, retaddr); __taint_trace_memerr(addr_label, addr, size_label, size, F_MEMERR_NULL, retaddr); if (flags().exit_on_memerror) Die(); else return; } if (addr_label == kInitializingLabel) { AOUT("WARNING: uninitialized memory %p = %d @%p\n", (void*)addr, addr_label, retaddr); __taint_trace_memerr(addr_label, addr, size_label, size, F_MEMERR_UBI, retaddr); if (flags().exit_on_memerror) Die(); else return; } dfsan_label_info *info = get_label_info(addr_label); if (info->op == __dfsan::Free) { // UAF AOUT("ERROR: UAF detected %p = %d @%p\n", (void*)addr, addr_label, retaddr); __taint_trace_memerr(addr_label, addr, size_label, size, F_MEMERR_UAF, retaddr); if (flags().exit_on_memerror) Die(); } else if (info->op == __dfsan::Alloca) { AOUT("addr = %p, lower = %p, upper = %p\n", (void*)addr, (void*)info->op1.i, (void*)info->op2.i); if (addr < info->op1.i) { AOUT("ERROR: OOB underflow detected %p = %d, %lu = %d @%p\n", (void*)addr, addr_label, size, size_label, retaddr); __taint_trace_memerr(addr_label, addr, size_label, size, F_MEMERR_OLB, retaddr); if (flags().exit_on_memerror) Die(); } else if ((addr + size) > info->op2.i || (addr + size) < info->op1.i) { AOUT("ERROR: OOB overflow detected %p = %d, %lu = %d @%p\n", (void*)addr, addr_label, size, size_label, __builtin_return_address(0)); __taint_trace_memerr(addr_label, addr, size_label, size, F_MEMERR_OUB, retaddr); if (flags().exit_on_memerror) Die(); } } else if (addr_label != 0) { AOUT("WARNING: incorrect label %p = %d @%p\n", (void*)addr, addr_label, __builtin_return_address(0)); } } } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_solve_bounds(dfsan_label ptr_label, uint64_t ptr, dfsan_label index_label, int64_t index, uint64_t num_elems, uint64_t elem_size, int64_t current_offset, uint32_t cid) { if (index_label == 0 || !flags().solve_ub) return; void *addr = __builtin_return_address(0); if (index_label == kInitializingLabel) { // uninitialized label AOUT("WARNING: uninitialized label %u @%p\n", index_label, addr); __taint_trace_memerr(ptr_label, ptr, index_label, index, F_MEMERR_UBI, addr); if (flags().exit_on_memerror) Die(); else return; } if (ptr_label == kInitializingLabel) { // uninitialized label AOUT("WARNING: uninitialized label %u @%p\n", ptr_label, addr); __taint_trace_memerr(ptr_label, ptr, index_label, index, F_MEMERR_UBI, addr); if (flags().exit_on_memerror) Die(); else return; } AOUT("solve bounds: %ld = %d, ne: %ld, es: %ld, offset: %ld\n", index, index_label, num_elems, elem_size, current_offset); // construct bounds solving tasks here uint16_t index_bits = get_label_info(index_label)->size; if (num_elems > 0) { // array with known size // // check underflow, index < 0 dfsan_label lb = __taint_union(index_label, 0, (bvslt << 8) | ICmp, index_bits, index, 0); // assume the result is false, as bounds check should happen before solving // no flag, no nested __taint_trace_cond(lb, 0, UndefinedCheck, ub_index_underflow); // check overflow, index >= num_elems dfsan_label ub = __taint_union(index_label, 0, (bvsge << 8) | ICmp, index_bits, index, num_elems); __taint_trace_cond(ub, 0, UndefinedCheck, ub_index_overflow); } else { // array with unknown size dfsan_label_info *bounds_info = get_label_info(ptr_label); if (bounds_info->op == __dfsan::Alloca) { // bounds information is available, check if allocation size is symbolic if (index_bits < 64) // extends index to 64 bits index_label = __taint_union(index_label, 0, ZExt, 64, index, 0); if (bounds_info->l2 == 0) { // concrete allocation size, check bounds // check underflow, index * elem_size + current_offset + ptr < lower_bound // => index < (lower_bound - current_offset - ptr) / elem_size uint64_t lower_bound = (bounds_info->op1.i - current_offset - ptr) / elem_size; dfsan_label lb = __taint_union(index_label, 0, (bvult << 8) | ICmp, 64, index, lower_bound); __taint_trace_cond(lb, 0, UndefinedCheck, ub_index_underflow); // check overflow, (index + 1) * elem_size + current_offset + ptr > upper_bound // => index > (upper_bound - current_offset - ptr) / elem_size - 1 uint64_t upper_bound = (bounds_info->op2.i - current_offset - ptr) / elem_size - 1; dfsan_label ub = __taint_union(index_label, 0, (bvugt << 8) | ICmp, 64, index, upper_bound); __taint_trace_cond(ub, 0, UndefinedCheck, ub_index_overflow); } else { // index * elem_size + current_offset + (ptr - lower_bound) > array_size * alloc_elem_size dfsan_label size_label = elem_size == 1 ? index_label : __taint_union(index_label, 0, Mul, 64, index, elem_size); uint64_t size = index * elem_size; uint64_t offset = current_offset + ptr - bounds_info->op1.i; size_label = offset == 0 ? size : __taint_union(size_label, 0, Add, 64, size, offset); size += offset; uint64_t alloc_size = bounds_info->op2.i - bounds_info->op1.i; dfsan_label overflow = __taint_union(size_label, bounds_info->l2, (bvugt << 8) | ICmp, 64, size, alloc_size); __taint_trace_cond(overflow, 0, UndefinedCheck, ub_integer_to_buffer_overflow); } } else { // symbolic pointer but no bounds info? AOUT("WARNING: symbolic pointer %p = %u with no bounds info @%p\n", (void*)ptr, ptr_label, addr); // check if null is possible? dfsan_label null = __taint_union(ptr_label, 0, bveq, 64, ptr, 0); __taint_trace_cond(null, 0, UndefinedCheck, ub_null_pointer); } } } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_solve_size(dfsan_label ptr_label, uint64_t ptr, dfsan_label size_label, uint64_t size, uint32_t cid) { if (size_label == 0 || !flags().solve_ub) return; void *addr = __builtin_return_address(0); if (size_label == kInitializingLabel) { // uninitialized label AOUT("WARNING: uninitialized size label %u @%p\n", size_label, addr); __taint_trace_memerr(ptr_label, ptr, size_label, size, F_MEMERR_UBI, addr); if (flags().exit_on_memerror) Die(); else return; } if (ptr_label == kInitializingLabel) { // uninitialized label AOUT("WARNING: uninitialized pointer label %u @%p\n", ptr_label, addr); __taint_trace_memerr(ptr_label, ptr, size_label, size, F_MEMERR_UBI, addr); if (flags().exit_on_memerror) Die(); else return; } AOUT("solve size: %lu = %d, ptr: %p = %d\n", size, size_label, (void*)ptr, ptr_label); // construct size solving tasks here uint16_t size_bits = get_label_info(size_label)->size; // check overflow with buffer bounds if ptr has bounds info if (ptr_label != 0) { dfsan_label_info *bounds_info = get_label_info(ptr_label); if (bounds_info->op == __dfsan::Alloca) { // bounds information is available if (size_bits < 64) // extend size to 64 bits size_label = __taint_union(size_label, 0, ZExt, 64, size, 0); if (bounds_info->l2 == 0) { // concrete allocation size // check underflow: ptr + size < lower_bound (wrap around) // => size < lower_bound - ptr (when lower_bound > ptr, but this shouldn't happen in valid code) // or equivalently, check that ptr < lower_bound (shouldn't happen) uint64_t min_size = bounds_info->op1.i - ptr; dfsan_label underflow = __taint_union(size_label, 0, (bvult << 8) | ICmp, 64, size, min_size); __taint_trace_cond(underflow, 0, UndefinedCheck, ub_size_underflow); // check overflow: ptr + size > upper_bound // => size > upper_bound - ptr uint64_t max_size = bounds_info->op2.i - ptr; dfsan_label overflow = __taint_union(size_label, 0, (bvugt << 8) | ICmp, 64, size, max_size); __taint_trace_cond(overflow, 0, UndefinedCheck, ub_size_overflow); } else { // symbolic allocation size // check: size > alloc_size uint64_t offset = ptr - bounds_info->op1.i; uint64_t alloc_size = bounds_info->op2.i - bounds_info->op1.i; dfsan_label adjusted_size = offset == 0 ? size_label : __taint_union(size_label, 0, Add, 64, size, offset); uint64_t actual_size = size + offset; dfsan_label overflow = __taint_union(adjusted_size, bounds_info->l2, (bvugt << 8) | ICmp, 64, actual_size, alloc_size); __taint_trace_cond(overflow, 0, UndefinedCheck, ub_size_to_buffer_overflow); } } else if (ptr_label != 0) { // symbolic pointer but no bounds info AOUT("WARNING: symbolic pointer %p = %u with no bounds info @%p\n", (void*)ptr, ptr_label, addr); // check if null is possible dfsan_label null = __taint_union(ptr_label, 0, bveq, 64, ptr, 0); __taint_trace_cond(null, 0, UndefinedCheck, ub_null_pointer); } } } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void dfsan_store_label(dfsan_label l, void *addr, uptr size) { if (l == 0) return; __taint_union_store(l, shadow_for(addr), size, sizeof(dfsan_label)); } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __dfsan_unimplemented(char *fname) { if (flags().warn_unimplemented) Report("WARNING: DataFlowSanitizer: call to uninstrumented function %s\n", fname); } // Use '-mllvm -dfsan-debug-nonzero-labels' and break on this function // to try to figure out where labels are being introduced in a nominally // label-free program. extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __dfsan_nonzero_label() { if (flags().warn_nonzero_labels) Report("WARNING: DataFlowSanitizer: saw nonzero label\n"); } // Indirect call to an uninstrumented vararg function. We don't have a way of // handling these at the moment. extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __dfsan_vararg_wrapper(const char *fname) { Report("FATAL: DataFlowSanitizer: unsupported indirect call to vararg " "function %s\n", fname); Die(); } // Like __dfsan_union, but for use from the client or custom functions. Hence // the equality comparison is done here before calling __dfsan_union. SANITIZER_INTERFACE_ATTRIBUTE dfsan_label dfsan_union(dfsan_label l1, dfsan_label l2, uint16_t op, uint16_t size, uint64_t op1, uint64_t op2) { return __taint_union(l1, l2, op, size, op1, op2); } extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_label dfsan_create_label(off_t offset) { dfsan_label label = atomic_fetch_add(&__dfsan_last_label, 1, memory_order_relaxed) + 1; dfsan_check_label(label); internal_memset(&__dfsan_label_info[label], 0, sizeof(dfsan_label_info)); __dfsan_label_info[label].size = 8; // label may not equal to offset when using stdin __dfsan_label_info[label].op1.i = offset; // init a non-zero hash __dfsan_label_info[label].hash = xxhash(offset, 0, 8); return label; } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __dfsan_set_label(dfsan_label label, void *addr, uptr size) { if (addr == 0) return; for (dfsan_label *labelp = shadow_for(addr); size != 0; --size, ++labelp) { // Don't write the label if it is already the value we need it to be. // In a program where most addresses are not labeled, it is common that // a page of shadow memory is entirely zeroed. The Linux copy-on-write // implementation will share all of the zeroed pages, making a copy of a // page when any value is written. The un-sharing will happen even if // the value written does not change the value in memory. Avoiding the // write when both |label| and |*labelp| are zero dramatically reduces // the amount of real memory used by large programs. if (label == *labelp) continue; // AOUT("%p = %u\n", addr, label); *labelp = label; } } SANITIZER_INTERFACE_ATTRIBUTE void dfsan_set_label(dfsan_label label, void *addr, uptr size) { __dfsan_set_label(label, addr, size); } SANITIZER_INTERFACE_ATTRIBUTE void dfsan_add_label(dfsan_label label, uint8_t op, void *addr, uptr size) { for (dfsan_label *labelp = shadow_for(addr); size != 0; --size, ++labelp) *labelp = __taint_union(*labelp, label, op, 1, 0, 0); } // Unlike the other dfsan interface functions the behavior of this function // depends on the label of one of its arguments. Hence it is implemented as a // custom function. extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_label __dfsw_dfsan_get_label(long data, dfsan_label data_label, dfsan_label *ret_label) { *ret_label = 0; return data_label; } SANITIZER_INTERFACE_ATTRIBUTE dfsan_label dfsan_read_label(const void *addr, uptr size) { if (size == 0) return 0; return __taint_union_load(shadow_for(addr), size, sizeof(dfsan_label)); } SANITIZER_INTERFACE_ATTRIBUTE dfsan_label dfsan_get_label(const void *addr) { return *shadow_for(addr); } extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_label_info *dfsan_get_label_info(dfsan_label label) { dfsan_check_label(label); return &__dfsan_label_info[label]; } extern "C" SANITIZER_INTERFACE_ATTRIBUTE int dfsan_has_label(dfsan_label label, dfsan_label elem) { if (label == kInitializingLabel || elem == kInitializingLabel) return false; if (label == elem) return true; const dfsan_label_info *info = dfsan_get_label_info(label); if (info->l1 != 0) { return dfsan_has_label(info->l1, elem); } if (info->l2 != 0) { return dfsan_has_label(info->l2, elem); } return false; } extern "C" SANITIZER_INTERFACE_ATTRIBUTE uptr dfsan_get_label_count(void) { dfsan_label max_label_allocated = atomic_load(&__dfsan_last_label, memory_order_relaxed); return static_cast(max_label_allocated); } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void dfsan_dump_labels(int fd) { dfsan_label last_label = atomic_load(&__dfsan_last_label, memory_order_relaxed); for (dfsan_label l = 1; l <= last_label; ++l) { char buf[64]; internal_snprintf(buf, sizeof(buf), "%u (%u %u %u %u)", l, __dfsan_label_info[l].l1, __dfsan_label_info[l].l2, __dfsan_label_info[l].op, __dfsan_label_info[l].size); WriteToFile(fd, buf, internal_strlen(buf)); WriteToFile(fd, "\n", 1); } } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_debug(dfsan_label op1, dfsan_label op2, int predicate, uint32_t size, uint32_t target) { if (op1 == 0 && op2 == 0) return; } SANITIZER_INTERFACE_ATTRIBUTE void taint_set_file(int dirfd, const char *filename, int fd) { char path[PATH_MAX]; if (dirfd != AT_FDCWD) { // only resolve dirfd if not CWD ssize_t len = readlinkat(dirfd, filename, path, sizeof(path)); if (len < 0) { AOUT("WARNING: readlinkat failed %s\n", filename); return; } path[len] = '\0'; } realpath(filename, path); if (internal_strcmp(tainted.filename, path) == 0) { tainted.fd = fd; AOUT("fd:%d created\n", fd); } } SANITIZER_INTERFACE_ATTRIBUTE int is_taint_file(const char *filename) { char path[PATH_MAX]; realpath(filename, path); if (internal_strcmp(tainted.filename, path) == 0) { tainted.is_utmp = 1; return 1; } tainted.is_utmp = 0; return 0; } SANITIZER_INTERFACE_ATTRIBUTE off_t taint_get_file(int fd) { AOUT("fd: %d\n", fd); AOUT("tainted.fd: %d\n", tainted.fd); if (tainted.fd == fd) { return tainted.size; } else if (flags().force_stdin && fd == 0) { return tainted.size; } else { return 0; } } SANITIZER_INTERFACE_ATTRIBUTE void taint_close_file(int fd) { if (fd == tainted.fd) { AOUT("close tainted.fd: %d\n", tainted.fd); tainted.fd = -1; } } SANITIZER_INTERFACE_ATTRIBUTE int is_stdin_taint(void) { return tainted.is_stdin; } // for utmp interface SANITIZER_INTERFACE_ATTRIBUTE int is_utmp_taint(void) { return tainted.is_utmp; } SANITIZER_INTERFACE_ATTRIBUTE void set_utmp_offset(off_t offset) { tainted.offset = offset; } SANITIZER_INTERFACE_ATTRIBUTE off_t get_utmp_offset() { return tainted.offset; } SANITIZER_INTERFACE_ATTRIBUTE void taint_set_offset_label(dfsan_label label) { tainted.offset_label = label; } SANITIZER_INTERFACE_ATTRIBUTE dfsan_label taint_get_offset_label() { return tainted.offset_label; } SANITIZER_INTERFACE_ATTRIBUTE void taint_set_socket(const void *addr, unsigned addrlen, int fd) { const struct sockaddr *sa = (struct sockaddr *)addr; AOUT("taint host %s:%d\n", tainted_socket.host, tainted_socket.port); if (sa->sa_family != tainted_socket.family) return; if (sa->sa_family == AF_INET) { struct sockaddr_in *sin = (struct sockaddr_in *)sa; if (tainted_socket.port != ntohs(sin->sin_port)) return; struct in_addr addr; inet_pton(AF_INET, tainted_socket.host, &addr); if (addr.s_addr != sin->sin_addr.s_addr) return; // family, port, and address match AOUT("taint sockfd %d\n", fd); tainted_socket.fd = fd; } else if (sa->sa_family == AF_INET6) { struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa; if (tainted_socket.port != ntohs(sin6->sin6_port)) return; struct in6_addr addr; inet_pton(AF_INET6, tainted_socket.host, &addr); if (internal_memcmp(&addr, &sin6->sin6_addr, sizeof(addr)) != 0) return; // family, port, and address match AOUT("taint sockfd %d\n", fd); tainted_socket.fd = fd; } else if (sa->sa_family == AF_UNIX) { struct sockaddr_un *sun = (struct sockaddr_un *)sa; if (internal_strncmp(tainted_socket.host, sun->sun_path, sizeof(tainted_socket.host)) == 0) { AOUT("taint sockfd %d\n", fd); tainted_socket.fd = fd; } } } SANITIZER_INTERFACE_ATTRIBUTE off_t taint_get_socket(int fd) { if (tainted_socket.fd == fd) { return tainted_socket.offset; } else if (flags().force_stdin) { return tainted_socket.offset; } else { return -1; } } SANITIZER_INTERFACE_ATTRIBUTE void taint_update_socket_offset(int fd, size_t size) { if (tainted_socket.fd == fd) tainted_socket.offset += size; } SANITIZER_INTERFACE_ATTRIBUTE void taint_close_socket(int fd) { if (tainted_socket.fd == fd) { AOUT("close tainted_socket.fd: %d\n", tainted_socket.fd); tainted_socket.fd = -1; } } void Flags::SetDefaults() { #define DFSAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue; #include "dfsan_flags.inc" #undef DFSAN_FLAG } static void RegisterDfsanFlags(FlagParser *parser, Flags *f) { #define DFSAN_FLAG(Type, Name, DefaultValue, Description) \ RegisterFlag(parser, #Name, Description, &f->Name); #include "dfsan_flags.inc" #undef DFSAN_FLAG } static void InitializeTaintFile() { struct stat st; const char *filename = flags().taint_file; int err; if (internal_strcmp(filename, "stdin") == 0) { tainted.fd = 0; // try to get the size, as stdin may be a file if (!fstat(0, &st) && S_ISREG(st.st_mode)) { tainted.size = st.st_size; tainted.is_stdin = 0; // map a copy tainted.buf_size = RoundUpTo(st.st_size, GetPageSizeCached()); uptr map = internal_mmap(nullptr, tainted.buf_size, PROT_READ, MAP_PRIVATE, 0, 0); if (internal_iserror(map, &err)) { Printf("FATAL: failed to map a copy of input file %s\n", strerror(err)); Die(); } tainted.buf = reinterpret_cast(map); } else { tainted.size = 1; tainted.is_stdin = 1; // truly stdin } } else if (internal_strcmp(filename, "") == 0) { tainted.fd = -1; } else { if (!realpath(filename, tainted.filename)) { Report("WARNING: failed to get to real path for taint file\n"); return; } stat(filename, &st); tainted.size = st.st_size; tainted.is_stdin = 0; // map a copy tainted.buf = static_cast( MapFileToMemory(filename, &tainted.buf_size)); if (tainted.buf == nullptr) { Printf("FATAL: failed to map a copy of input file\n"); Die(); } AOUT("%s %ld size\n", filename, tainted.size); } if (tainted.fd != -1 && !tainted.is_stdin) { for (off_t i = 0; i < tainted.size; i++) { dfsan_label label = dfsan_create_label(i); dfsan_check_label(label); } } } static void InitializeTaintSocket() { const char *host = flags().taint_socket; internal_memset(tainted_socket.host, 0, sizeof(tainted_socket.host)); tainted_socket.family = -1; tainted_socket.port = -1; tainted_socket.fd = -1; if (internal_strstr(host, "tcp@") == host || internal_strstr(host, "udp@") == host) { char *port = internal_strchr(host + 4, '@'); if (port) { tainted_socket.family = AF_INET; size_t addr_len = (uptr)port - (uptr)host - 4; internal_memcpy(tainted_socket.host, host + 4, addr_len); tainted_socket.host[addr_len] = '\0'; tainted_socket.port = atoi(port + 1); } else { Report("FATAL: invalid inet socket %s\n", host); Die(); } } else if (internal_strstr(host, "tcp6@") == host || internal_strstr(host, "udp6@") == host) { char *port = internal_strchr(host + 5, '@'); if (port) { tainted_socket.family = AF_INET6; size_t addr_len = (uptr)port - (uptr)host - 5; internal_memcpy(tainted_socket.host, host + 5, addr_len); tainted_socket.host[addr_len] = '\0'; tainted_socket.port = atoi(port + 1); } else { Report("FATAL: invalid inet6 socket %s\n", host); Die(); } } else if (internal_strstr(host, "unix@") == host) { tainted_socket.family = AF_UNIX; uptr len = internal_strlen(host + 5); if (len < sizeof(tainted_socket.host)) { internal_memcpy(tainted_socket.host, host + 5, len); } else { Report("FATAL: invalid unix socket %s\n", host); Die(); } } else if (internal_strcmp(host, "")) { Report("FATAL: unsupported taint socket %s\n", host); Die(); } } // Hash tables for string label tracking static uptr content_map_capacity = 0; static struct { uptr addr; dfsan_label label; } *__taint_content_map = nullptr; static uptr content_map_count = 0; static uptr indexof_map_capacity = 0; static struct { uptr addr; dfsan_label label; } *__taint_indexof_map = nullptr; static uptr indexof_map_count = 0; // Hash function optimized for shadow memory addresses (0x700000040000 ~ 0x800000000000) // Focus on middle bits where entropy is highest static inline uptr hash_addr(uptr addr, uptr capacity) { addr >>= 3; // Remove low 3 bits (8-byte alignment) addr *= 2654435769UL; // Multiplicative hash return addr & (capacity - 1); // Fast modulo for power-of-2 } // Grow content map when load factor exceeds 0.7 static void grow_content_map() { uptr new_capacity = content_map_capacity * 2; typeof(__taint_content_map) new_map = (typeof(__taint_content_map))InternalAlloc( new_capacity * sizeof(*__taint_content_map)); internal_memset(new_map, 0, new_capacity * sizeof(*__taint_content_map)); // Rehash existing entries for (uptr i = 0; i < content_map_capacity; i++) { if (__taint_content_map[i].addr != 0) { uptr hash = hash_addr(__taint_content_map[i].addr, new_capacity); while (new_map[hash].addr != 0) { hash = (hash + 1) & (new_capacity - 1); } new_map[hash] = __taint_content_map[i]; } } InternalFree(__taint_content_map); __taint_content_map = new_map; content_map_capacity = new_capacity; } // Grow indexOf map static void grow_indexof_map() { uptr new_capacity = indexof_map_capacity * 2; typeof(__taint_indexof_map) new_map = (typeof(__taint_indexof_map))InternalAlloc( new_capacity * sizeof(*__taint_indexof_map)); internal_memset(new_map, 0, new_capacity * sizeof(*__taint_indexof_map)); for (uptr i = 0; i < indexof_map_capacity; i++) { if (__taint_indexof_map[i].addr != 0) { uptr hash = hash_addr(__taint_indexof_map[i].addr, new_capacity); while (new_map[hash].addr != 0) { hash = (hash + 1) & (new_capacity - 1); } new_map[hash] = __taint_indexof_map[i]; } } InternalFree(__taint_indexof_map); __taint_indexof_map = new_map; indexof_map_capacity = new_capacity; } static void InitializeStringMaps() { // Round up to nearest power of 2 for efficient hashing uptr capacity = flags().string_map_capacity; if (capacity < 16) capacity = 16; // Minimum size // Round up to power of 2 capacity--; capacity |= capacity >> 1; capacity |= capacity >> 2; capacity |= capacity >> 4; capacity |= capacity >> 8; capacity |= capacity >> 16; capacity |= capacity >> 32; capacity++; // Content map content_map_capacity = capacity; __taint_content_map = (typeof(__taint_content_map))InternalAlloc( content_map_capacity * sizeof(*__taint_content_map)); internal_memset(__taint_content_map, 0, content_map_capacity * sizeof(*__taint_content_map)); content_map_count = 0; // IndexOf map indexof_map_capacity = capacity; __taint_indexof_map = (typeof(__taint_indexof_map))InternalAlloc( indexof_map_capacity * sizeof(*__taint_indexof_map)); internal_memset(__taint_indexof_map, 0, indexof_map_capacity * sizeof(*__taint_indexof_map)); indexof_map_count = 0; } extern "C" void taint_set_str_content_label(void *addr, dfsan_label label) { AOUT("taint_set_str_content_label: addr=%p, label=%u\n", addr, label); // Grow if needed if (content_map_count > (content_map_capacity * 7 / 10)) { grow_content_map(); } uptr hash = hash_addr((uptr)addr, content_map_capacity); // Linear probing while (__taint_content_map[hash].addr != 0 && __taint_content_map[hash].addr != (uptr)addr) { hash = (hash + 1) & (content_map_capacity - 1); } if (__taint_content_map[hash].addr == 0) { content_map_count++; } else { AOUT("update content label: old = %u\n", __taint_content_map[hash].label); } __taint_content_map[hash].addr = (uptr)addr; __taint_content_map[hash].label = label; } extern "C" dfsan_label taint_get_str_content_label(const void *addr) { uptr hash = hash_addr((uptr)addr, content_map_capacity); uptr start = hash; while (__taint_content_map[hash].addr != 0) { if (__taint_content_map[hash].addr == (uptr)addr) { AOUT("taint_get_str_content_label: addr=%p, found label=%u\n", addr, __taint_content_map[hash].label); return __taint_content_map[hash].label; } hash = (hash + 1) & (content_map_capacity - 1); if (hash == start) break; } AOUT("addr=%p, not found\n", addr); return 0; } extern "C" void taint_set_str_indexof_label(void *addr, dfsan_label label) { AOUT("taint_set_str_indexof_label: addr=%p, label=%u\n", addr, label); if (indexof_map_count > (indexof_map_capacity * 7 / 10)) { grow_indexof_map(); } uptr hash = hash_addr((uptr)addr, indexof_map_capacity); while (__taint_indexof_map[hash].addr != 0 && __taint_indexof_map[hash].addr != (uptr)addr) { hash = (hash + 1) & (indexof_map_capacity - 1); } if (__taint_indexof_map[hash].addr == 0) { indexof_map_count++; } else { AOUT("update indexof label: old = %u\n", __taint_indexof_map[hash].label); } __taint_indexof_map[hash].addr = (uptr)addr; __taint_indexof_map[hash].label = label; } extern "C" dfsan_label taint_get_str_indexof_label(const void *addr) { uptr hash = hash_addr((uptr)addr, indexof_map_capacity); uptr start = hash; while (__taint_indexof_map[hash].addr != 0) { if (__taint_indexof_map[hash].addr == (uptr)addr) { AOUT("addr=%p, found label=%u\n", addr, __taint_indexof_map[hash].label); return __taint_indexof_map[hash].label; } hash = (hash + 1) & (indexof_map_capacity - 1); if (hash == start) break; } AOUT("addr=%p, not found\n", addr); return 0; } // information is passed implicitly through flags() extern "C" void InitializeSolver(); static void InitializeFlags() { SetCommonFlagsDefaults(); flags().SetDefaults(); FlagParser parser; RegisterCommonFlags(&parser); RegisterDfsanFlags(&parser, &flags()); parser.ParseString(GetEnv("TAINT_OPTIONS")); InitializeCommonFlags(); if (Verbosity()) ReportUnrecognizedFlags(); if (common_flags()->help) parser.PrintFlagDescriptions(); } static void InitializePlatformEarly() { AvoidCVE_2016_2143(); #ifdef DFSAN_RUNTIME_VMA __dfsan::vmaSize = (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1); if (__dfsan::vmaSize == 39 || __dfsan::vmaSize == 42 || __dfsan::vmaSize == 48) { __dfsan_shadow_ptr_mask = ShadowMask(); } else { Printf("FATAL: DataFlowSanitizer: unsupported VMA range\n"); Printf("FATAL: Found %d - Supported 39, 42, and 48\n", __dfsan::vmaSize); Die(); } #endif } static void dfsan_fini() { if (internal_strcmp(flags().dump_labels_at_exit, "") != 0) { fd_t fd = OpenFile(flags().dump_labels_at_exit, WrOnly); if (fd == kInvalidFd) { Report("WARNING: DataFlowSanitizer: unable to open output file %s\n", flags().dump_labels_at_exit); return; } Report("INFO: DataFlowSanitizer: dumping labels to %s\n", flags().dump_labels_at_exit); dfsan_dump_labels(fd); CloseFile(fd); } if (tainted.buf) { UnmapOrDie(tainted.buf, tainted.buf_size); } if (flags().shm_fd != -1) { internal_munmap((void *)UnionTableAddr(), uniontable_size); } } static void dfsan_init(int argc, char **argv, char **envp) { InitializeFlags(); print_debug = flags().debug; ::InitializePlatformEarly(); uptr ret; int err; ret = MmapFixedSuperNoReserve(ShadowAddr(), UnionTableAddr() - ShadowAddr()); if (internal_iserror(ret, &err)) { Printf("FATAL: error mapping shadow %s\n", strerror(err)); Die(); } // init union table __dfsan_label_info = (dfsan_label_info *)UnionTableAddr(); if (flags().shm_fd != -1) { AOUT("shm_fd %d\n", flags().shm_fd); ret = internal_mmap((void*)UnionTableAddr(), uniontable_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, flags().shm_fd, 0); } else { ret = MmapFixedSuperNoReserve(UnionTableAddr(), uniontable_size); } if (internal_iserror(ret, &err)) { Printf("FATAL: error mapping shared union table %s\n", strerror(err)); Die(); } // init const label internal_memset(&__dfsan_label_info[CONST_LABEL], 0, sizeof(dfsan_label_info)); __dfsan_label_info[CONST_LABEL].size = 8; // init hashtable allocator __taint::allocator_init(HashTableAddr(), HashTableAddr() + hashtable_size); // init main thread auto num_of_labels = uniontable_size / sizeof(dfsan_label_info); __alloca_stack_top = __alloca_stack_bottom = (dfsan_label)(num_of_labels - 2); // Protect the region of memory we don't use, to preserve the one-to-one // mapping from application to shadow memory. But if ASLR is disabled, Linux // will load our executable in the middle of our unused region. This mostly // works so long as the program doesn't use too much memory. We support this // case by disabling memory protection when ASLR is disabled. uptr init_addr = (uptr)&dfsan_init; if (!(init_addr >= UnusedAddr() && init_addr < AppAddr())) MmapFixedNoAccess(UnusedAddr(), AppAddr() - UnusedAddr()); InitializeInterceptors(); InitializeTaintFile(); InitializeTaintSocket(); InitializeStringMaps(); InitializeSolver(); // Register the fini callback to run when the program terminates successfully // or it is killed by the runtime. Atexit(dfsan_fini); AddDieCallback(dfsan_fini); } #if SANITIZER_CAN_USE_PREINIT_ARRAY __attribute__((section(".preinit_array"), used)) static void (*dfsan_init_ptr)(int, char **, char **) = dfsan_init; #endif extern "C" { SANITIZER_INTERFACE_WEAK_DEF(void, InitializeSolver, void) {} // Default empty implementations (weak) for hooks SANITIZER_INTERFACE_WEAK_DEF(void, __taint_trace_cmp, dfsan_label, dfsan_label, uint32_t, uint32_t, uint64_t, uint64_t, uint32_t) {} SANITIZER_INTERFACE_WEAK_DEF(void, __taint_trace_cond, dfsan_label, bool, uint8_t, uint32_t) {} SANITIZER_INTERFACE_WEAK_DEF(void, __taint_trace_loop, uint32_t, uint32_t) {} SANITIZER_INTERFACE_WEAK_DEF(void, __taint_trace_switch_end, uint32_t) {} SANITIZER_INTERFACE_WEAK_DEF(dfsan_label, __taint_trace_select, dfsan_label, dfsan_label, dfsan_label, uint8_t, uint8_t, uint8_t, uint32_t) {return 0;} SANITIZER_INTERFACE_WEAK_DEF(void, __taint_trace_indcall, dfsan_label) {} SANITIZER_INTERFACE_WEAK_DEF(void, __taint_trace_gep, dfsan_label, uint64_t, dfsan_label, int64_t, uint64_t, uint64_t, int64_t, uint32_t) {} SANITIZER_INTERFACE_WEAK_DEF(void, __taint_trace_offset, dfsan_label, int64_t, unsigned) {} SANITIZER_INTERFACE_WEAK_DEF(void, __taint_trace_memcmp, dfsan_label) {} SANITIZER_INTERFACE_WEAK_DEF(void, __taint_trace_distance, uint64_t, uint64_t) {} SANITIZER_WEAK_ATTRIBUTE THREADLOCAL uint32_t __taint_trace_callstack; } // extern "C" ================================================ FILE: runtime/dfsan/dfsan.h ================================================ //===-- dfsan.h -------------------------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file is a part of DataFlowSanitizer. // // Private DFSan header. //===----------------------------------------------------------------------===// #ifndef DFSAN_H #define DFSAN_H #include "sanitizer_common/sanitizer_internal_defs.h" #include "dfsan_platform.h" #include #include using __sanitizer::uptr; extern bool print_debug; # define AOUT(...) \ do { \ if (print_debug) { \ Printf("[RT] (%s:%d) ", __FUNCTION__, __LINE__); \ Printf(__VA_ARGS__); \ } \ } while(false) // Copy declarations from public sanitizer/dfsan_interface.h header here. typedef uint32_t dfsan_label; typedef union { uint64_t i; float f; double d; } data; struct dfsan_label_info { dfsan_label l1; dfsan_label l2; data op1; data op2; uint16_t op; uint16_t size; // FIXME: this limit the size of the operand to 65535 bits or bytes (in case of memcmp) uint32_t hash; } __attribute__((aligned (8), packed)); #ifndef PATH_MAX # define PATH_MAX 4096 #endif #define CONST_OFFSET 1 #define CONST_LABEL 0 static const size_t uniontable_size = 0xc00000000; // FIXME struct taint_file { char filename[PATH_MAX]; int fd; off_t offset; dfsan_label offset_label; dfsan_label label; off_t size; uint8_t is_stdin; uint8_t is_utmp; char *buf; uptr buf_size; }; struct taint_socket { int family; int port; int fd; off_t offset; char host[PATH_MAX]; }; extern "C" { void dfsan_add_label(dfsan_label label, uint8_t op, void *addr, uptr size); void dfsan_set_label(dfsan_label label, void *addr, uptr size); dfsan_label dfsan_read_label(const void *addr, uptr size); void dfsan_store_label(dfsan_label l1, void *addr, uptr size); dfsan_label dfsan_union(dfsan_label l1, dfsan_label l2, uint16_t op, uint16_t size, uint64_t op1, uint64_t op2); dfsan_label dfsan_create_label(off_t offset); dfsan_label dfsan_get_label(const void *addr); dfsan_label_info* dfsan_get_label_info(dfsan_label label); // taint source void taint_set_file(int dirfd, const char *filename, int fd); off_t taint_get_file(int fd); void taint_close_file(int fd); int is_taint_file(const char *filename); int is_stdin_taint(void); void taint_set_offset_label(dfsan_label label); dfsan_label taint_get_offset_label(); // taint tracking for string operations void taint_set_str_content_label(void *addr, dfsan_label label); dfsan_label taint_get_str_content_label(const void *addr); void taint_set_str_indexof_label(void *addr, dfsan_label label); dfsan_label taint_get_str_indexof_label(const void *addr); // taint source utmp off_t get_utmp_offset(void); void set_utmp_offset(off_t offset); int is_utmp_taint(void); // taint source socket void taint_set_socket(const void *addr, unsigned addrlen, int fd); off_t taint_get_socket(int fd); void taint_update_socket_offset(int fd, size_t size); void taint_close_socket(int fd); } // extern "C" template void dfsan_set_label(dfsan_label label, T &data) { // NOLINT dfsan_set_label(label, (void *)&data, sizeof(T)); } namespace __dfsan { const dfsan_label kInitializingLabel = -1; void InitializeInterceptors(); inline dfsan_label *shadow_for(void *ptr) { return (dfsan_label *) ((((uptr) ptr) & ShadowMask()) << 2); } inline const dfsan_label *shadow_for(const void *ptr) { return shadow_for(const_cast(ptr)); } inline void *app_for(const dfsan_label *l) { return (void *) ((((uptr) l) >> 2) | AppBaseAddr()); } dfsan_label_info* get_label_info(dfsan_label label); struct Flags { #define DFSAN_FLAG(Type, Name, DefaultValue, Description) Type Name; #include "dfsan_flags.inc" #undef DFSAN_FLAG void SetDefaults(); }; extern Flags flags_data; inline Flags &flags() { return flags_data; } // taint source extern struct taint_file tainted; extern struct taint_socket tainted_socket; enum operators { Not = 1, Neg = 2, #define HANDLE_BINARY_INST(num, opcode, Class) opcode = num, #define HANDLE_MEMORY_INST(num, opcode, Class) opcode = num, #define HANDLE_CAST_INST(num, opcode, Class) opcode = num, #define HANDLE_OTHER_INST(num, opcode, Class) opcode = num, #define LAST_OTHER_INST(num) last_llvm_op = num, #include "llvm/IR/Instruction.def" #undef HANDLE_BINARY_INST #undef HANDLE_MEMORY_INST #undef HANDLE_CAST_INST #undef HANDLE_OTHER_INST #undef LAST_OTHER_INST // last_llvm_op = 67 for llvm14 // self-defined Free = last_llvm_op + 3, // 70 Extract = last_llvm_op + 4, // 71 Concat = last_llvm_op + 5, // 72 Arg = last_llvm_op + 6, // 73 // higher-order fmemcmp = last_llvm_op + 7, // 74 fsize = last_llvm_op + 8, // 75 fatoi = last_llvm_op + 9, // 76 fstrlen = last_llvm_op + 10, // 77 // string search ops that return positions (for chaining detection) fstr_op_start = last_llvm_op + 11, // 78 fstrchr = last_llvm_op + 11, // 78 strchr/memchr fstrrchr = last_llvm_op + 12, // 79 strrchr/memrchr fstrstr = last_llvm_op + 13, // 80 strstr/memmem fstrpbrk = last_llvm_op + 14, // 81 strpbrk - find first char from set fstr_off = last_llvm_op + 15, // 82 string op + constant offset (for ptr arithmetic) fsubstr = last_llvm_op + 16, // 83 substr(s, 0, len) - for bounded search fstrcat = last_llvm_op + 17, // 84 strcat/strncat - string concatenation fstr_op_end = last_llvm_op + 18, // 85 // string comparison (returns 0/1, NOT a position - must be outside fstr_op range) fstrcmp = last_llvm_op + 18, // 85 strcmp using Z3 string theory fprefixof = last_llvm_op + 19, // 86 prefixof(str, prefix) using Z3 string theory fsuffixof = last_llvm_op + 20, // 87 suffixof(str, suffix) using Z3 string theory LastOp = last_llvm_op + 21, // 88 }; enum predicate { bveq = 32, bvneq = 33, bvugt = 34, bvuge = 35, bvult = 36, bvule = 37, bvsgt = 38, bvsge = 39, bvslt = 40, bvsle = 41 }; static inline uint8_t get_const_result(uint64_t c1, uint64_t c2, uint32_t predicate) { switch (predicate) { case bveq: return c1 == c2; case bvneq: return c1 != c2; case bvugt: return c1 > c2; case bvuge: return c1 >= c2; case bvult: return c1 < c2; case bvule: return c1 <= c2; case bvsgt: return (int64_t)c1 > (int64_t)c2; case bvsge: return (int64_t)c1 >= (int64_t)c2; case bvslt: return (int64_t)c1 < (int64_t)c2; case bvsle: return (int64_t)c1 <= (int64_t)c2; default: break; } return 0; } static inline bool is_commutative(unsigned char op) { switch(op) { case Not: case And: case Or: case Xor: case Add: case Mul: case fmemcmp: case fstrcmp: return true; default: return false; } } // for out-of-process solving enum pipe_msg_type { cond_type = 0, gep_type = 1, memcmp_type = 2, fsize_type = 3, memerr_type = 4, }; static const uint8_t TrueBranchLoopLatch = 0x8; static const uint8_t FalseBranchLoopLatch = 0x4; static const uint8_t TrueBranchLoopExit = 0x2; static const uint8_t FalseBranchLoopExit = 0x1; static const uint8_t LoopFlagMask = 0xF; static const uint8_t UndefinedCheck = 0x10; enum undefined_check_ids { ub_integer_overflow = 1, ub_division_by_zero, ub_shift_exponent, ub_shift_overflow, ub_shift_base, ub_index_underflow, ub_index_overflow, ub_size_underflow, ub_size_overflow, ub_size_to_buffer_overflow, ub_integer_to_buffer_overflow, ub_null_pointer, ub_unsigned_integer_truncation, ub_signed_integer_truncation, ub_integer_sign_change, }; #define F_ADD_CONS 0x1 #define F_LOOP_EXIT 0x2 #define F_LOOP_LATCH 0x4 #define F_MEMERR_UAF 0x1 #define F_MEMERR_OLB 0x2 #define F_MEMERR_OUB 0x4 #define F_MEMERR_UBI 0x8 #define F_MEMERR_NULL 0x10 #define F_MEMERR_FREE 0x20 // double free struct pipe_msg { uint16_t msg_type; uint16_t flags; uint32_t instance_id; uptr addr; uint32_t context; uint32_t id; uint32_t label; uint64_t result; } __attribute__((packed)); // additional info for gep struct gep_msg { uint32_t ptr_label; uint32_t index_label; uptr ptr; int64_t index; uint64_t num_elems; uint64_t elem_size; int64_t current_offset; } __attribute__((packed)); // saving the memcmp target struct memcmp_msg { uint32_t label; uint8_t content[0]; } __attribute__((packed)); } // namespace __dfsan #endif // DFSAN_H ================================================ FILE: runtime/dfsan/dfsan.syms.extra ================================================ dfsan_* __dfsan_* __dfsw_* __taint_* ================================================ FILE: runtime/dfsan/dfsan_custom.cpp ================================================ //===-- dfsan.cc ----------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of DataFlowSanitizer. // // This file defines the custom functions listed in done_abilist.txt. //===----------------------------------------------------------------------===// #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "dfsan.h" #include "sanitizer_common/sanitizer_common.h" #include "sanitizer_common/sanitizer_internal_defs.h" #include "sanitizer_common/sanitizer_linux.h" #include "sanitizer_common/sanitizer_stackdepot.h" using namespace __dfsan; #define CALL_WEAK_INTERCEPTOR_HOOK(f, ...) \ do { \ if (f) \ f(__VA_ARGS__); \ } while (false) #define DECLARE_WEAK_INTERCEPTOR_HOOK(f, ...) \ SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void f(__VA_ARGS__); #define AIXCC_HACK 1 static off_t current_stdin_offset = 0; // Check if an op is a string operation (fstr_op_start to fstr_op_end) static inline bool is_string_op(uint16_t op) { return op >= __dfsan::fstr_op_start && op < __dfsan::fstr_op_end; } // Check if an op is an indexOf-type operation (returns position, not content) // These are: fstrchr, fstrrchr, fstrstr, fstrpbrk, fstr_off static inline bool is_indexof_op(uint16_t op) { return op >= __dfsan::fstrchr && op <= __dfsan::fstr_off; } // Check if an op is a content-type string operation (fsubstr, fstrcat) static inline bool is_content_string_op(uint16_t op) { return op == __dfsan::fsubstr || op == __dfsan::fstrcat; } // Helper: Find the first (base) input byte label from a content label. // Walks through Concat chains and Load operations to find the starting input. // Returns the base label, or 0 if not found. static dfsan_label get_base_input_label(dfsan_label label) { if (label < CONST_OFFSET) return 0; dfsan_label_info *info = dfsan_get_label_info(label); // Base input label has op == 0 if (info->op == 0) return label; // For Concat (op 72), walk left (l1) to find the base if (info->op == __dfsan::Concat) { return get_base_input_label(info->l1); } // For Load (op 32), l1 is the starting label if (info->op == __dfsan::Load) { return info->l1; } // For other ops, try l1 if (info->l1 >= CONST_OFFSET) { return get_base_input_label(info->l1); } return 0; } // Helper: Find if a label derives from a string op (fstrchr, fstrrchr, fstrstr) // by walking through PtrToInt, Sub, Add operations. // Returns the string op label if found, 0 otherwise. static dfsan_label find_string_op_source(dfsan_label label) { if (label < CONST_OFFSET) return 0; dfsan_label_info *info = dfsan_get_label_info(label); uint16_t op = info->op; // Check if this is directly a string op if (is_string_op(op)) { return label; } // Follow through PtrToInt, Sub, Add to find the source string op if (op == __dfsan::PtrToInt || op == __dfsan::Sub || op == __dfsan::Add) { // Recursively check l1 (the primary operand) if (info->l1 >= CONST_OFFSET) { dfsan_label result = find_string_op_source(info->l1); if (result != 0) return result; } // For Sub/Add, also check l2 if ((op == __dfsan::Sub || op == __dfsan::Add) && info->l2 >= CONST_OFFSET) { dfsan_label result = find_string_op_source(info->l2); if (result != 0) return result; } } return 0; } // Unified method to get string label with explicit length // Checks (in order): // 1. Runtime content map (for strncpy/strcat destinations) // 2. Pointer label itself being a content-type string op (for chaining) // 3. indexOf map at address s for suffix case (strcpy from pos+1) // 4. If n_label derives from a string op, create fsubstr to preserve constraint // 5. Buffer content labels via dfsan_read_label static inline dfsan_label get_str_label_n(const void *s, dfsan_label s_label, size_t n, dfsan_label n_label) { AOUT("get_str_label_n: s=%p, s_label=%u, n=%zu, n_label=%u\n", s, s_label, n, n_label); // 1. Check content map for fsubstr/fstrcat labels (from strncpy/strcat destinations) dfsan_label content = taint_get_str_content_label(s); if (content != 0) { AOUT("get_str_label_n: step 1 returns content=%u\n", content); return content; } // 2. Check if pointer label itself is a content-type string op (for chaining) // Only chain on fsubstr/fstrcat, NOT indexOf ops (fstrchr, fstrrchr, etc.) if (s_label >= CONST_OFFSET) { dfsan_label_info *info = dfsan_get_label_info(s_label); AOUT("get_str_label_n: step 2 s_label op=%u, is_content=%d\n", info ? info->op : 0, info ? is_content_string_op(info->op) : 0); if (info && is_content_string_op(info->op)) { AOUT("get_str_label_n: step 2 returns s_label=%u\n", s_label); return s_label; } } // 3. Check for suffix case: searching from a previous indexOf result position // Creates fsubstr(content, start_pos, remaining) for: // a) strcpy(suffix, pos + 1) where gep_ptr stored fstr_off at pos+1 // b) memchr(t1, c, len) where t1 was returned by previous indexOf dfsan_label start_label = taint_get_str_indexof_label(s); if (start_label != 0) { dfsan_label_info *start_info = dfsan_get_label_info(start_label); if (start_info) { dfsan_label indexOf_label = 0; if (start_info->op == __dfsan::fstr_off && start_info->l1 >= CONST_OFFSET) { // Case 3a: fstr_off points to indexOf op indexOf_label = start_info->l1; } else if (is_indexof_op(start_info->op)) { // Case 3b: Direct indexOf - only if s_label confirms indexOf origin // This distinguishes memchr(t1,...) from memchr(buf,...) when t1==buf dfsan_label_info *s_info = (s_label >= CONST_OFFSET) ? dfsan_get_label_info(s_label) : nullptr; if (s_info && is_indexof_op(s_info->op)) { indexOf_label = start_label; } } if (indexOf_label != 0) { dfsan_label_info *idx_info = dfsan_get_label_info(indexOf_label); if (idx_info && idx_info->l1 >= CONST_OFFSET) { // Create suffix fsubstr: substr(content, start_pos, remaining) // l1=content, l2=position label, op1=concrete len, op2=1 (suffix mode) return dfsan_union(idx_info->l1, start_label, __dfsan::fsubstr, sizeof(void*) * 8, (uint64_t)n, 1); } } } } // 4. Check if n_label derives from a string op (e.g., ptr arithmetic on memchr result) // If so, create fsubstr to represent substr(content, 0, idx) where idx is the string op result // IMPORTANT: Do this even when n=0 to preserve the symbolic constraint! dfsan_label str_op_label = find_string_op_source(n_label); if (str_op_label != 0) { dfsan_label_info *str_op_info = dfsan_get_label_info(str_op_label); dfsan_label str_op_content = str_op_info->l1; if (str_op_content >= CONST_OFFSET) { // Get content label from buffer if available for same-buffer verification dfsan_label content_label = (n > 0) ? dfsan_read_label(s, n) : 0; // Verify same underlying buffer only if content is available bool same_buffer = true; if (content_label != 0) { dfsan_label src_base = get_base_input_label(content_label); dfsan_label str_op_base = get_base_input_label(str_op_content); same_buffer = (src_base != 0 && src_base == str_op_base); } // When n=0, trust that n_label derives from same buffer // (the alternative is losing the constraint entirely) if (same_buffer) { // Create fsubstr: substr(str_op_content, 0, str_op_label) // l1 = original content, l2 = string op label (index), op1 = concrete n, op2 = 0 return dfsan_union(str_op_content, str_op_label, __dfsan::fsubstr, sizeof(void*) * 8, (uint64_t)n, 0); } } } // 5. Fall back to reading buffer content labels return dfsan_read_label(s, n); } // Unified method to get string label for null-terminated strings // Uses strlen to determine length // Also checks if null terminator was placed at a strchr/strstr result position static inline dfsan_label get_str_label(const char *s, dfsan_label s_label) { size_t len = strlen(s); // Check if null terminator was placed at a position found by strchr/strstr/etc. // This allows us to recover symbolic length when code does: // pos = strchr(buf, '_'); *pos = '\0'; strcpy(dest, buf); dfsan_label term_label = taint_get_str_indexof_label(s + len); return get_str_label_n(s, s_label, len + 1, term_label); } static inline dfsan_label get_label_for(int fd, off_t offset) { // check if fd is stdin, if so, the label hasn't been pre-allocated if (is_stdin_taint() || (fd ==0 && flags().force_stdin)) return dfsan_create_label(current_stdin_offset++); // if fd is a tainted file, the label should have been pre-allocated else return (offset + CONST_OFFSET); } static void *dfsan_memcpy(void *dest, const void *src, size_t n) { if (n == 0) return dest; dfsan_label *sdest = shadow_for(dest); const dfsan_label *ssrc = shadow_for(src); // FIXME: check and avoid copying labels? internal_memcpy((void *)sdest, (const void *)ssrc, n * sizeof(dfsan_label)); return internal_memcpy(dest, src, n); } static void dfsan_memset(void *s, int c, dfsan_label c_label, size_t n) { if (n == 0) return; internal_memset(s, c, n); dfsan_set_label(c_label, s, n); } extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_offset(dfsan_label offset_label, int64_t offset, unsigned size); extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_memcmp(dfsan_label label); extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_check_bounds(dfsan_label addr_label, uptr addr, dfsan_label size_label, uint64_t size); extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_cond(dfsan_label label, bool r, uint8_t flag, uint32_t cid); extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_solve_bounds(dfsan_label ptr_label, uint64_t ptr, dfsan_label index_label, int64_t index, uint64_t num_elems, uint64_t elem_size, int64_t current_offset, uint32_t cid); extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_solve_size(dfsan_label ptr_label, uint64_t ptr, dfsan_label size_label, uint64_t size, uint32_t cid); extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_memerr(dfsan_label ptr_label, uptr ptr, dfsan_label size_label, uint64_t size, uint16_t flag, void *addr); extern "C" { SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_stat(const char *path, struct stat *buf, dfsan_label path_label, dfsan_label buf_label, dfsan_label *ret_label) { int ret = stat(path, buf); if (ret == 0) { dfsan_set_label(0, buf, sizeof(struct stat)); if (flags().trace_fsize && is_taint_file(path)) { dfsan_label size = dfsan_union(0, 0, fsize, sizeof(buf->st_size) * 8, 0, 0); dfsan_set_label(size, &buf->st_size, sizeof(buf->st_size)); } } *ret_label = 0; return ret; } #if __GLIBC__ <= 2 && __GLIBC_MINOR__ < 33 SANITIZER_INTERFACE_ATTRIBUTE int __dfsw___xstat(int vers, const char *path, struct stat *buf, dfsan_label vers_label, dfsan_label path_label, dfsan_label buf_label, dfsan_label *ret_label) { int ret = __xstat(vers, path, buf); if (ret == 0) { dfsan_set_label(0, buf, sizeof(struct stat)); if (flags().trace_fsize && is_taint_file(path)) { dfsan_label size = dfsan_union(0, 0, fsize, sizeof(buf->st_size) * 8, 0, 0); dfsan_set_label(size, &buf->st_size, sizeof(buf->st_size)); } } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw___fxstat(int vers, const int fd, struct stat *buf, dfsan_label vers_label, dfsan_label fd_label, dfsan_label buf_label, dfsan_label *ret_label) { int ret = __fxstat(vers, fd, buf); if (ret == 0) { dfsan_set_label(0, buf, sizeof(struct stat)); if (flags().trace_fsize && taint_get_file(fd)) { dfsan_label size = dfsan_union(0, 0, fsize, sizeof(buf->st_size) * 8, 0, 0); dfsan_set_label(size, &buf->st_size, sizeof(buf->st_size)); } } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw___lxstat(int vers, const char *path, struct stat *buf, dfsan_label vers_label, dfsan_label path_label, dfsan_label buf_label, dfsan_label *ret_label) { int ret = __lxstat(vers, path, buf); if (ret == 0) { dfsan_set_label(0, buf, sizeof(struct stat)); if (flags().trace_fsize && is_taint_file(path)) { dfsan_label size = dfsan_union(0, 0, fsize, sizeof(buf->st_size) * 8, 0, 0); dfsan_set_label(size, &buf->st_size, sizeof(buf->st_size)); } } *ret_label = 0; return ret; } #endif SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_fstat(int fd, struct stat *buf, dfsan_label fd_label, dfsan_label buf_label, dfsan_label *ret_label) { int ret = fstat(fd, buf); if (ret == 0) { dfsan_set_label(0, buf, sizeof(struct stat)); if (flags().trace_fsize && taint_get_file(fd)) { dfsan_label size = dfsan_union(0, 0, fsize, sizeof(buf->st_size) * 8, 0, 0); dfsan_set_label(size, &buf->st_size, sizeof(buf->st_size)); } } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_lstat(const char *path, struct stat *buf, dfsan_label path_label, dfsan_label buf_label, dfsan_label *ret_label) { int ret = lstat(path, buf); if (ret == 0) { dfsan_set_label(0, buf, sizeof(struct stat)); if (flags().trace_fsize && is_taint_file(path)) { dfsan_label size = dfsan_union(0, 0, fsize, sizeof(buf->st_size) * 8, 0, 0); dfsan_set_label(size, &buf->st_size, sizeof(buf->st_size)); } } *ret_label = 0; return ret; } // Create a label for string op + constant offset (for pointer arithmetic like sep + 1) // If base_label is a string op, returns a new fstr_off label; otherwise returns base_label extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __taint_trace_gep_ptr(dfsan_label base_label, char *result, char *base) { if (base_label < CONST_OFFSET) return; // Check if base_label is or derives from a string op dfsan_label str_op_label = find_string_op_source(base_label); if (str_op_label == 0) { // Not a string op - return base label unchanged return; } // Create fstr_off label: l1=str_op_label, op1=offset // This represents the content at (string_op_position + offset) uint64_t offset = (uint64_t)(result - base); dfsan_label off_label = dfsan_union(str_op_label, 0, __dfsan::fstr_off, sizeof(void*) * 8, 0, (uint64_t)offset); AOUT("gep_ptr: base=%u, str_op=%u, offset=%ld, result=%u\n", base_label, str_op_label, offset, off_label); // record the label (fstr_off is an indexOf-type op) taint_set_str_indexof_label(result, off_label); } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strchr(char *s, int c, dfsan_label s_label, dfsan_label c_label, dfsan_label *ret_label) { char *ret = strchr(s, c); // Use unified get_str_label to get source label // Handles str_map, pointer label fsubstr, and buffer content dfsan_label src_label = get_str_label(s, s_label); // Create label if source or char is tainted if (src_label != 0 || c_label != 0) { // Determine which operand is concrete and set size accordingly size_t haystack_len = strlen(s); uint16_t content_len = (src_label == 0) ? (uint16_t)haystack_len : 0; // l1 = src_label (source - for chaining or content dependencies) // l2 = c_label (target char - may be symbolic!) // op1 = haystack pointer (for concrete content retrieval) // op2 = char value // size = haystack length if concrete, else 0 *ret_label = dfsan_union(src_label, c_label, __dfsan::fstrchr, content_len, (uint64_t)s, (uint64_t)(uint8_t)c); // Send concrete haystack content if haystack is concrete if (content_len > 0 && *ret_label) { __taint_trace_memcmp(*ret_label); } // Store the result pointer to recover symbolic length if (ret) { taint_set_str_indexof_label(ret, *ret_label); } } else { *ret_label = 0; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strpbrk(const char *s, const char *accept, dfsan_label s_label, dfsan_label accept_label, dfsan_label *ret_label) { const char *ret = strpbrk(s, accept); size_t accept_len = strlen(accept); // Use unified get_str_label for source string dfsan_label src_label = get_str_label(s, s_label); // Use unified get_str_label for accept string dfsan_label real_accept_label = get_str_label(accept, accept_label); if (src_label != 0 || real_accept_label != 0) { // Determine which operand is concrete and set size accordingly size_t haystack_len = strlen(s); uint16_t content_len = 0; if (src_label == 0) { content_len = (uint16_t)haystack_len; } else if (real_accept_label == 0) { content_len = (uint16_t)accept_len; } // l1 = src_label (source content) // l2 = accept_label (character set - may be symbolic) // op1 = haystack pointer (for concrete content retrieval) // op2 = accept pointer (for concrete content retrieval) // size = haystack length if haystack concrete, else accept length if accept concrete, else 0 dfsan_label label = dfsan_union(src_label, real_accept_label, __dfsan::fstrpbrk, content_len, (uint64_t)s, (uint64_t)accept); // Send concrete content (haystack or accept) if (content_len > 0 && label) { __taint_trace_memcmp(label); } *ret_label = label; // Store the result pointer to recover symbolic length if (ret) { taint_set_str_indexof_label(const_cast(ret), *ret_label); } } else { *ret_label = 0; } return const_cast(ret); } DECLARE_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_memcmp, uptr caller_pc, const void *s1, const void *s2, size_t n, dfsan_label s1_label, dfsan_label s2_label, dfsan_label n_label) SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_memcmp(const void *s1, const void *s2, size_t n, dfsan_label s1_label, dfsan_label s2_label, dfsan_label n_label, dfsan_label *ret_label) { CALL_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_memcmp, GET_CALLER_PC(), s1, s2, n, s1_label, s2_label, n_label); __taint_check_bounds(s1_label, (uptr)s1, n_label, n); __taint_check_bounds(s2_label, (uptr)s2, n_label, n); int ret = memcmp(s1, s2, n); // Check for fsubstr labels dfsan_label l1 = get_str_label_n(s1, s1_label, n, n_label); dfsan_label l2 = get_str_label_n(s2, s2_label, n, n_label); if (l1 == 0 && l2 == 0) { *ret_label = 0; return ret; } // Check if either side is a string op - use string theory comparison bool l1_is_string_op = (l1 >= CONST_OFFSET && is_string_op(dfsan_get_label_info(l1)->op)); bool l2_is_string_op = (l2 >= CONST_OFFSET && is_string_op(dfsan_get_label_info(l2)->op)); uint16_t op = (l1_is_string_op || l2_is_string_op) ? __dfsan::fstrcmp : __dfsan::fmemcmp; dfsan_label cmp = dfsan_union(l1, l2, op, n, (uint64_t)s1, (uint64_t)s2); if (cmp) __taint_trace_memcmp(cmp); *ret_label = cmp; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_bcmp(const void *s1, const void *s2, size_t n, dfsan_label s1_label, dfsan_label s2_label, dfsan_label n_label, dfsan_label *ret_label) { __taint_check_bounds(s1_label, (uptr)s1, n_label, n); __taint_check_bounds(s2_label, (uptr)s2, n_label, n); int ret = bcmp(s1, s2, n); // Check for fsubstr labels (from strncpy with symbolic length) dfsan_label l1 = get_str_label_n(s1, s1_label, n, n_label); dfsan_label l2 = get_str_label_n(s2, s2_label, n, n_label); if (l1 == 0 && l2 == 0) { *ret_label = 0; return ret; } // Check if either side is a string op - use string theory comparison bool l1_is_string_op = (l1 >= CONST_OFFSET && is_string_op(dfsan_get_label_info(l1)->op)); bool l2_is_string_op = (l2 >= CONST_OFFSET && is_string_op(dfsan_get_label_info(l2)->op)); uint16_t op = (l1_is_string_op || l2_is_string_op) ? __dfsan::fstrcmp : __dfsan::fmemcmp; dfsan_label cmp = dfsan_union(l1, l2, op, n, (uint64_t)s1, (uint64_t)s2); if (cmp) __taint_trace_memcmp(cmp); *ret_label = cmp; return ret; } DECLARE_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strcmp, uptr caller_pc, const char *s1, const char *s2, dfsan_label s1_label, dfsan_label s2_label) SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_strcmp(const char *s1, const char *s2, dfsan_label s1_label, dfsan_label s2_label, dfsan_label *ret_label) { CALL_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strcmp, GET_CALLER_PC(), s1, s2, s1_label, s2_label); int ret = strcmp(s1, s2); AOUT("strcmp: s1=%p s2=%p s1_label=%u s2_label=%u\n", s1, s2, s1_label, s2_label); // Use unified get_str_label to get labels for both strings // Handles str_map, pointer label fsubstr, and buffer content dfsan_label l1 = get_str_label(s1, s1_label); dfsan_label l2 = get_str_label(s2, s2_label); AOUT("strcmp: l1=%u l2=%u\n", l1, l2); if (l1 == 0 && l2 == 0) { *ret_label = 0; } else { // Determine length for comparison (use concrete side if one is fsubstr) size_t n = strlen(s1) + 1; dfsan_label s1_fsubstr = taint_get_str_content_label(s1); if (s1_fsubstr != 0) n = strlen(s2) + 1; // use concrete side for length // fstrcmp is commutative - dfsan_union will swap to put concrete in op1 dfsan_label cmp = dfsan_union(l1, l2, __dfsan::fstrcmp, n, (uint64_t)s1, (uint64_t)s2); if (cmp) __taint_trace_memcmp(cmp); *ret_label = cmp; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_prefixof( const char *str, const char *prefix, dfsan_label str_label, dfsan_label prefix_label, dfsan_label *ret_label) { // Execute concrete operation (simple check) int ret = 0; size_t prefix_len = strlen(prefix); size_t str_len = strlen(str); if (str_len >= prefix_len && memcmp(str, prefix, prefix_len) == 0) { ret = 1; } // Get unified labels (handles fsubstr chaining and content maps) dfsan_label l1 = get_str_label(str, str_label); dfsan_label l2 = get_str_label(prefix, prefix_label); if (l1 == 0 && l2 == 0) { *ret_label = 0; } else { // Determine length for memcmp_cache (use concrete side if one is fsubstr) size_t n = strlen(str) + 1; dfsan_label str_fsubstr = taint_get_str_content_label(str); if (str_fsubstr != 0) n = strlen(prefix) + 1; // use concrete side for length // Create label - fprefixof is commutative, dfsan_union will normalize dfsan_label cmp = dfsan_union(l1, l2, __dfsan::fprefixof, n, (uint64_t)str, (uint64_t)prefix); if (cmp) __taint_trace_memcmp(cmp); *ret_label = cmp; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_suffixof( const char *str, const char *suffix, dfsan_label str_label, dfsan_label suffix_label, dfsan_label *ret_label) { // Execute concrete operation int ret = 0; size_t suffix_len = strlen(suffix); size_t str_len = strlen(str); if (str_len >= suffix_len && memcmp(str + (str_len - suffix_len), suffix, suffix_len) == 0) { ret = 1; } // Get unified labels dfsan_label l1 = get_str_label(str, str_label); dfsan_label l2 = get_str_label(suffix, suffix_label); if (l1 == 0 && l2 == 0) { *ret_label = 0; } else { // Determine length for memcmp_cache size_t n = strlen(str) + 1; dfsan_label str_fsubstr = taint_get_str_content_label(str); if (str_fsubstr != 0) n = strlen(suffix) + 1; // Create label dfsan_label cmp = dfsan_union(l1, l2, __dfsan::fsuffixof, n, (uint64_t)str, (uint64_t)suffix); if (cmp) __taint_trace_memcmp(cmp); *ret_label = cmp; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strsub( const char *s, size_t start, size_t len, dfsan_label s_label, dfsan_label start_label, dfsan_label len_label, dfsan_label *ret_label) { *ret_label = 0; // Execute concrete operation // Skip 'start' characters, then duplicate 'len' characters if (s == NULL || len == 0) { return NULL; } size_t str_len = strlen(s); if (start >= str_len) { return NULL; } // Point to start position const char *src = s + start; size_t remaining = str_len - start; size_t copy_len = (len < remaining) ? len : remaining; // Allocate and copy substring (like strndup) char *p = (char *)malloc(copy_len + 1); if (p == NULL) { return NULL; } dfsan_memcpy(p, src, copy_len); p[copy_len] = '\0'; // Get unified label for the string dfsan_label str_label = get_str_label(s, s_label); if (str_label == 0 && start_label == 0 && len_label == 0) { // No taint, nothing to propagate } else { // Compose strsub(str, start, len) using two fsubstr operations: // 1. suffix_from_pos(str, start) = str[start:] using fsubstr with op2=1 (suffix mode) // 2. prefix(suffix, len) = suffix[0:len] using fsubstr with op2=0 (prefix mode) // Step 1: Create suffix label representing str[start:] // l1 = string content, l2 = start position label // op1 = concrete remaining length, op2 = 1 (suffix mode) dfsan_label suffix_label = str_label; if (start_label != 0 || start > 0) { suffix_label = dfsan_union(str_label, start_label, __dfsan::fsubstr, sizeof(void*) * 8, (uint64_t)remaining, 1); } // Step 2: Take first len chars from suffix: suffix[0:len] // l1 = suffix label, l2 = len label // op1 = concrete len, op2 = 0 (prefix mode) dfsan_label substr_label = dfsan_union(suffix_label, len_label, __dfsan::fsubstr, sizeof(void*) * 8, (uint64_t)copy_len, 0); // Store label in content map so downstream ops can find it if (substr_label != 0) { taint_set_str_content_label(p, substr_label); *ret_label = substr_label; } } return p; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_strcasecmp(const char *s1, const char *s2, dfsan_label s1_label, dfsan_label s2_label, dfsan_label *ret_label) { int ret = strcasecmp(s1, s2); // doing an optimistic solving, hoping we can get the same case // Use unified get_str_label for fsubstr support dfsan_label l1 = get_str_label(s1, s1_label); dfsan_label l2 = get_str_label(s2, s2_label); if (l1 == 0 && l2 == 0) { *ret_label = 0; } else { size_t n = strlen(s1) + 1; dfsan_label s1_fsubstr = taint_get_str_content_label(s1); if (s1_fsubstr != 0) n = strlen(s2) + 1; // fstrcmp is commutative - dfsan_union will swap to put concrete in op1 dfsan_label cmp = dfsan_union(l1, l2, __dfsan::fstrcmp, n, (uint64_t)s1, (uint64_t)s2); if (cmp) __taint_trace_memcmp(cmp); *ret_label = cmp; } return ret; } DECLARE_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strncmp, uptr caller_pc, const char *s1, const char *s2, size_t n, dfsan_label s1_label, dfsan_label s2_label, dfsan_label n_label) SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_strncmp(const char *s1, const char *s2, size_t n, dfsan_label s1_label, dfsan_label s2_label, dfsan_label n_label, dfsan_label *ret_label) { if (n == 0) { *ret_label = 0; return 0; } CALL_WEAK_INTERCEPTOR_HOOK(dfsan_weak_hook_strncmp, GET_CALLER_PC(), s1, s2, n, s1_label, s2_label, n_label); int ret = strncmp(s1, s2, n); // Use unified get_str_label for fsubstr support dfsan_label l1 = get_str_label(s1, s1_label); dfsan_label l2 = get_str_label(s2, s2_label); if (l1 == 0 && l2 == 0) { *ret_label = 0; } else { // Adjust n for shorter strings when one side is concrete if (l1 == 0 && strlen(s1) < (n - 1)) n = strlen(s1) + 1; if (l2 == 0 && strlen(s2) < (n - 1)) n = strlen(s2) + 1; dfsan_label cmp = dfsan_union(l1, l2, __dfsan::fstrcmp, n, (uint64_t)s1, (uint64_t)s2); if (cmp) __taint_trace_memcmp(cmp); *ret_label = cmp; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_strncasecmp(const char *s1, const char *s2, size_t n, dfsan_label s1_label, dfsan_label s2_label, dfsan_label n_label, dfsan_label *ret_label) { if (n == 0) { *ret_label = 0; return 0; } int ret = strncasecmp(s1, s2, n); // doing an optimistic solving here too, hoping the case can be the same // Use unified get_str_label for fsubstr support dfsan_label l1 = get_str_label(s1, s1_label); dfsan_label l2 = get_str_label(s2, s2_label); if (l1 == 0 && l2 == 0) { *ret_label = 0; } else { // Adjust n for shorter strings when one side is concrete if (l1 == 0 && strlen(s1) < (n - 1)) n = strlen(s1) + 1; if (l2 == 0 && strlen(s2) < (n - 1)) n = strlen(s2) + 1; dfsan_label cmp = dfsan_union(l1, l2, __dfsan::fstrcmp, n, (uint64_t)s1, (uint64_t)s2); if (cmp) __taint_trace_memcmp(cmp); *ret_label = cmp; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE size_t __dfsw_strlen(const char *s, dfsan_label s_label, dfsan_label *ret_label) { size_t ret = strlen(s); dfsan_label str_label = dfsan_read_label(s, ret + 1); if (str_label == 0) { *ret_label = 0; } else { // Check if the null terminator byte is from input (tainted) // If not, it was added programmatically (e.g., by the program setting '\0') dfsan_label null_label = dfsan_read_label(s + ret, 1); bool null_from_input = (null_label != 0); // Create fstrlen label: // - l1 = 0 (following fsize/fatoi pattern to avoid Alloca rejection) // - l2 = str_label (content label for dependencies) // - op1 = null_from_input flag (1 if null is from input, 0 if programmatic) // - op2 = actual length (for solution generation) // Note: str_label contains the offset info via Load labels *ret_label = dfsan_union(0, str_label, fstrlen, sizeof(size_t) * 8, null_from_input ? 1 : 0, ret); } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_memcpy(void *dest, const void *src, size_t n, dfsan_label dest_label, dfsan_label src_label, dfsan_label n_label, dfsan_label *ret_label) { __taint_check_bounds(src_label, (uptr)src, n_label, n); __taint_check_bounds(dest_label, (uptr)dest, n_label, n); if (n_label) { __taint_solve_bounds(src_label, (uint64_t)src, n_label, n, 0, 1, 0, 0); __taint_solve_bounds(dest_label, (uint64_t)dest, n_label, n, 0, 1, 0, 0); } *ret_label = dest_label; return dfsan_memcpy(dest, src, n); } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_memmove(void *dest, const void *src, size_t n, dfsan_label dest_label, dfsan_label src_label, dfsan_label n_label, dfsan_label *ret_label) { __taint_check_bounds(src_label, (uptr)src, n_label, n); __taint_check_bounds(dest_label, (uptr)dest, n_label, n); if (n_label) { __taint_solve_bounds(src_label, (uint64_t)src, n_label, n, 0, 1, 0, 0); __taint_solve_bounds(dest_label, (uint64_t)dest, n_label, n, 0, 1, 0, 0); } dfsan_label tmp[n]; dfsan_label *sdest = shadow_for(dest); const dfsan_label *ssrc = shadow_for(src); internal_memcpy((void *)tmp, (const void *)ssrc, n * sizeof(dfsan_label)); void *ret = internal_memmove(dest, src, n); internal_memcpy((void *)sdest, (const void *)tmp, n * sizeof(dfsan_label)); *ret_label = dest_label; return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_memset(void *s, int c, size_t n, dfsan_label s_label, dfsan_label c_label, dfsan_label n_label, dfsan_label *ret_label) { __taint_check_bounds(s_label, (uptr)s, n_label, n); if (n_label) __taint_solve_bounds(s_label, (uint64_t)s, n_label, n, 0, 1, 0, 0); dfsan_memset(s, c, c_label, n); *ret_label = s_label; return s; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_tolower(int c, dfsan_label c_label, dfsan_label *ret_label) { int ret = tolower(c); *ret_label = dfsan_union(0, c_label, __dfsan::Or, 8, 0x20, 0); return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_toupper(int c, dfsan_label c_label, dfsan_label *ret_label) { int ret = toupper(c); *ret_label = dfsan_union(0, c_label, __dfsan::And, 8, 0x5f, 0); return ret; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strcat(char *dest, const char *src, dfsan_label d_label, dfsan_label s_label, dfsan_label *ret_label) { size_t dest_len = strlen(dest); size_t copy_len = strlen(src) + 1; // including tailing '\0' __taint_check_bounds(d_label, (uptr)dest, 0, dest_len + copy_len); // Get labels for both strings using unified label retrieval dfsan_label dest_str_label = get_str_label(dest, d_label); dfsan_label src_str_label = get_str_label(src, s_label); AOUT("strcat: dest=%p, src=%p, dest_label=%u, src_label=%u, " "dest_str_label=%u, src_str_label=%u\n", dest, src, d_label, s_label, dest_str_label, src_str_label); // Perform the actual strcat (copy src to dest + dest_len) dfsan_memcpy(dest + dest_len, src, copy_len); // If either string is tainted, create fstrcat label if (dest_str_label != 0 || src_str_label != 0) { // Create fstrcat: l1=dest, l2=src // op1=dest pointer, op2=src pointer (for concrete content access) // size = length of concrete operand (for memcmp_cache), 0 if both symbolic size_t src_len = copy_len - 1; // excluding null uint16_t concrete_len = 0; if (dest_str_label == 0) { concrete_len = (uint16_t)dest_len; } else if (src_str_label == 0) { concrete_len = (uint16_t)src_len; } dfsan_label concat_label = dfsan_union(dest_str_label, src_str_label, __dfsan::fstrcat, concrete_len, (uint64_t)dest, (uint64_t)src); AOUT("strcat: created fstrcat label=%u\n", concat_label); // Send concrete content through pipe if one side is concrete if (concrete_len > 0) { __taint_trace_memcmp(concat_label); } // Store in str_map so downstream ops can find it taint_set_str_content_label(dest, concat_label); } *ret_label = d_label; return dest; } SANITIZER_INTERFACE_ATTRIBUTE char * __dfsw_strncat(char *dest, const char *src, size_t n, dfsan_label d_label, dfsan_label s_label, dfsan_label n_label, dfsan_label *ret_label) { size_t dest_len = strlen(dest); size_t src_len = strlen(src); size_t copy_len = (n < src_len) ? n : src_len; // min(n, strlen(src)) __taint_check_bounds(d_label, (uptr)dest, 0, dest_len + copy_len + 1); AOUT("strncat: dest=%p, src=%p, n=%zu, d_label=%u, s_label=%u, n_label=%u\n", dest, src, n, d_label, s_label, n_label); // Get dest label using unified label retrieval dfsan_label dest_str_label = get_str_label(dest, d_label); // Get src label - use get_str_label_n to handle symbolic n // This will create fsubstr if n_label derives from a string op (e.g., strchr) dfsan_label src_str_label = get_str_label_n(src, s_label, copy_len, n_label); AOUT("strncat: dest_str_label=%u, src_str_label=%u, copy_len=%zu\n", dest_str_label, src_str_label, copy_len); // Perform the actual strncat dfsan_memcpy(dest + dest_len, src, copy_len); dest[dest_len + copy_len] = '\0'; // If either string is tainted, create fstrcat label if (dest_str_label != 0 || src_str_label != 0) { // Create fstrcat: l1=dest, l2=src // op1=dest pointer, op2=src pointer (for concrete content access) // size = length of concrete operand (for memcmp_cache), 0 if both symbolic uint16_t concrete_len = 0; if (dest_str_label == 0) { concrete_len = (uint16_t)dest_len; } else if (src_str_label == 0) { concrete_len = (uint16_t)copy_len; } dfsan_label concat_label = dfsan_union(dest_str_label, src_str_label, __dfsan::fstrcat, concrete_len, (uint64_t)dest, (uint64_t)src); AOUT("strncat: created fstrcat label=%u\n", concat_label); // Send concrete content through pipe if one side is concrete if (concrete_len > 0) { __taint_trace_memcmp(concat_label); } // Store in content map so downstream ops can find it taint_set_str_content_label(dest, concat_label); } *ret_label = d_label; return dest; } SANITIZER_INTERFACE_ATTRIBUTE char * __dfsw_strdup(const char *s, dfsan_label s_label, dfsan_label *ret_label) { size_t len = strlen(s); void *p = malloc(len+1); if (p == nullptr) { *ret_label = 0; return nullptr; } dfsan_memcpy(p, s, len+1); // Propagate string label to duplicated string dfsan_label str_label = get_str_label(s, s_label); if (str_label != 0) { taint_set_str_content_label(static_cast(p), str_label); } *ret_label = 0; return static_cast(p); } SANITIZER_INTERFACE_ATTRIBUTE char * __dfsw_strndup(const char *s, size_t n, dfsan_label s_label, dfsan_label n_label, dfsan_label *ret_label) { size_t len = strnlen(s, n); void *p = malloc(len + 1); if (p == nullptr) { *ret_label = 0; return nullptr; } dfsan_memcpy(p, s, len); ((char *)p)[len] = '\0'; // Propagate string label to duplicated string dfsan_label str_label = get_str_label_n(s, s_label, len, n_label); if (str_label != 0) { taint_set_str_content_label(static_cast(p), str_label); } *ret_label = 0; return static_cast(p); } SANITIZER_INTERFACE_ATTRIBUTE char * __dfsw___strdup(const char *s, dfsan_label s_label, dfsan_label *ret_label) { size_t len = strlen(s); void *p = malloc(len+1); if (p == nullptr) { *ret_label = 0; return nullptr; } dfsan_memcpy(p, s, len+1); // Propagate string label to duplicated string dfsan_label str_label = get_str_label(s, s_label); if (str_label != 0) { taint_set_str_content_label(static_cast(p), str_label); } *ret_label = 0; return static_cast(p); } SANITIZER_INTERFACE_ATTRIBUTE char * __dfsw___strndup(const char *s, size_t n, dfsan_label s_label, dfsan_label n_label, dfsan_label *ret_label) { size_t len = strnlen(s, n); char *p = static_cast(malloc(len+1)); if (p == nullptr) { *ret_label = 0; return nullptr; } dfsan_memcpy(p, s, len); // copy at most n bytes p[len] = '\0'; // Propagate string label to duplicated string dfsan_label str_label = get_str_label_n(s, s_label, len, n_label); if (str_label != 0) { taint_set_str_content_label(static_cast(p), str_label); } *ret_label = 0; return p; } SANITIZER_INTERFACE_ATTRIBUTE char * __dfsw_strncpy(char *s1, const char *s2, size_t n, dfsan_label s1_label, dfsan_label s2_label, dfsan_label n_label, dfsan_label *ret_label) { size_t len = strlen(s2); size_t copy_len = len < n ? len : n; if (n_label) __taint_solve_bounds(s1_label, (uint64_t)s1, n_label, n, 0, 1, 0, 0); // Check if n_label derives from a string op (e.g., strchr index) dfsan_label str_op_label = n_label ? find_string_op_source(n_label) : 0; bool created_fsubstr = false; if (str_op_label != 0) { // Get the content label from the string op dfsan_label_info *str_op_info = dfsan_get_label_info(str_op_label); dfsan_label str_op_content = str_op_info->l1; // content from strchr // Verify buffers match: str_op searched the same buffer we're copying // When copy_len = 0, we can't read from s2, so trust str_op_content bool buffers_match = false; if (str_op_content >= CONST_OFFSET) { if (copy_len > 0) { dfsan_label src_content = dfsan_read_label(s2, copy_len); if (src_content >= CONST_OFFSET) { dfsan_label src_base = get_base_input_label(src_content); dfsan_label str_op_base = get_base_input_label(str_op_content); buffers_match = (src_base != 0 && src_base == str_op_base); } } else { // copy_len = 0: trust the str_op_content (empty substring case) buffers_match = true; } } if (buffers_match) { // Create fsubstr: represents substr(src, 0, len) where len is symbolic // Use str_op_content (full haystack) for proper string theory solving dfsan_label substr_label = dfsan_union(str_op_content, str_op_label, __dfsan::fsubstr, sizeof(void*) * 8, (uint64_t)n, 0); // Store fsubstr label in runtime map keyed by destination address // This survives buffer content being overwritten (e.g., key[len] = '\0') taint_set_str_content_label(s1, substr_label); *ret_label = s1_label; } } // Normal case: copy byte-by-byte labels if (len < n) { dfsan_memcpy(s1, s2, len + 1); } else { dfsan_memcpy(s1, s2, n); } // Handle padding (strncpy pads with zeros if len < n) if (len < n) { dfsan_memset(s1 + len + 1, 0, 0, n - len - 1); } *ret_label = s1_label; return s1; } SANITIZER_INTERFACE_ATTRIBUTE ssize_t __dfsw_pread(int fd, void *buf, size_t count, off_t offset, dfsan_label fd_label, dfsan_label buf_label, dfsan_label count_label, dfsan_label offset_label, dfsan_label *ret_label) { __taint_check_bounds(buf_label, (uptr)buf, count_label, count); if (count_label) __taint_solve_bounds(buf_label, (uint64_t)buf, count_label, count, 0, 1, 0, 0); ssize_t ret = pread(fd, buf, count, offset); *ret_label = 0; if (ret >= 0) { if (taint_get_file(fd)) { for (ssize_t i = 0; i < ret; i++) { dfsan_set_label(get_label_for(fd, offset + i), (char *)buf + i, 1); } // *ret_label = dfsan_union(0, 0, fsize, sizeof(ret) * 8, offset, 0); } else { dfsan_set_label(0, buf, ret); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE ssize_t __dfsw_pread64(int fd, void *buf, size_t count, off_t offset, dfsan_label fd_label, dfsan_label buf_label, dfsan_label count_label, dfsan_label offset_label, dfsan_label *ret_label) { __taint_check_bounds(buf_label, (uptr)buf, count_label, count); if (count_label) __taint_solve_bounds(buf_label, (uint64_t)buf, count_label, count, 0, 1, 0, 0); ssize_t ret = pread64(fd, buf, count, offset); *ret_label = 0; if (ret >= 0) { if (taint_get_file(fd)) { for (ssize_t i = 0; i < ret; i++) { dfsan_set_label(get_label_for(fd, offset + i), (char *)buf + i, 1); } // *ret_label = dfsan_union(0, 0, fsize, sizeof(ret) * 8, offset, 0); } else { dfsan_set_label(0, buf, ret); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE ssize_t __dfsw_read(int fd, void *buf, size_t count, dfsan_label fd_label, dfsan_label buf_label, dfsan_label count_label, dfsan_label *ret_label) { off_t offset = lseek(fd, 0, SEEK_CUR); __taint_check_bounds(buf_label, (uptr)buf, count_label, count); if (count_label) __taint_solve_bounds(buf_label, (uint64_t)buf, count_label, count, 0, 1, 0, 0); ssize_t ret = read(fd, buf, count); *ret_label = 0; if (ret >= 0) { if (taint_get_file(fd)) { AOUT("offset = %ld, ret = %ld\n", offset, ret); for(ssize_t i = 0; i < ret; i++) { dfsan_set_label(get_label_for(fd, offset + i), (char *)buf + i, 1); } // for (size_t i = ret; i < count; i++) // dfsan_set_label(-1, (char *)buf + i, 1); // *ret_label = dfsan_union(0, 0, fsize, sizeof(ret) * 8, offset, 0); } else { dfsan_set_label(0, buf, ret); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_clock_gettime(clockid_t clk_id, struct timespec *tp, dfsan_label clk_id_label, dfsan_label tp_label, dfsan_label *ret_label) { int ret = clock_gettime(clk_id, tp); if (ret == 0) dfsan_set_label(0, tp, sizeof(struct timespec)); *ret_label = 0; return ret; } static void dfsan_set_zero_label(const void *ptr, uptr size) { dfsan_set_label(0, const_cast(ptr), size); } // dlopen() ultimately calls mmap() down inside the loader, which generally // doesn't participate in dynamic symbol resolution. Therefore we won't // intercept its calls to mmap, and we have to hook it here. SANITIZER_INTERFACE_ATTRIBUTE void * __dfsw_dlopen(const char *filename, int flag, dfsan_label filename_label, dfsan_label flag_label, dfsan_label *ret_label) { void *handle = dlopen(filename, flag); link_map *map = GET_LINK_MAP_BY_DLOPEN_HANDLE(handle); if (map && map->l_addr) ForEachMappedRegion(map, dfsan_set_zero_label); *ret_label = 0; return handle; } struct pthread_create_info { void *(*start_routine_trampoline)(void *, void *, dfsan_label, dfsan_label *); void *start_routine; void *arg; }; static void *pthread_create_cb(void *p) { pthread_create_info pci(*(pthread_create_info *)p); free(p); dfsan_label ret_label; return pci.start_routine_trampoline(pci.start_routine, pci.arg, 0, &ret_label); } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_pthread_create( pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine_trampoline)(void *, void *, dfsan_label, dfsan_label *), void *start_routine, void *arg, dfsan_label thread_label, dfsan_label attr_label, dfsan_label start_routine_label, dfsan_label arg_label, dfsan_label *ret_label) { pthread_create_info *pci = (pthread_create_info *)malloc(sizeof(pthread_create_info)); pci->start_routine_trampoline = start_routine_trampoline; pci->start_routine = start_routine; pci->arg = arg; int rv = pthread_create(thread, attr, pthread_create_cb, (void *)pci); if (rv != 0) free(pci); *ret_label = 0; return rv; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_pthread_join(pthread_t thread, void **retval, dfsan_label thread_label, dfsan_label retval_label, dfsan_label *ret_label) { int ret = pthread_join(thread, retval); if (ret == 0 && retval) dfsan_set_label(0, retval, sizeof(*retval)); *ret_label = 0; return ret; } struct dl_iterate_phdr_info { int (*callback_trampoline)(void *callback, struct dl_phdr_info *info, size_t size, void *data, dfsan_label info_label, dfsan_label size_label, dfsan_label data_label, dfsan_label *ret_label); void *callback; void *data; }; int dl_iterate_phdr_cb(struct dl_phdr_info *info, size_t size, void *data) { dl_iterate_phdr_info *dipi = (dl_iterate_phdr_info *)data; dfsan_set_label(0, *info); dfsan_set_label(0, const_cast(info->dlpi_name), strlen(info->dlpi_name) + 1); dfsan_set_label( 0, const_cast(reinterpret_cast(info->dlpi_phdr)), sizeof(*info->dlpi_phdr) * info->dlpi_phnum); dfsan_label ret_label; return dipi->callback_trampoline(dipi->callback, info, size, dipi->data, 0, 0, 0, &ret_label); } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_dl_iterate_phdr( int (*callback_trampoline)(void *callback, struct dl_phdr_info *info, size_t size, void *data, dfsan_label info_label, dfsan_label size_label, dfsan_label data_label, dfsan_label *ret_label), void *callback, void *data, dfsan_label callback_label, dfsan_label data_label, dfsan_label *ret_label) { dl_iterate_phdr_info dipi = { callback_trampoline, callback, data }; *ret_label = 0; return dl_iterate_phdr(dl_iterate_phdr_cb, &dipi); } #if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 27 // This function is only available for glibc 2.27 or newer. Mark it weak so // linking succeeds with older glibcs. SANITIZER_WEAK_ATTRIBUTE void _dl_get_tls_static_info(size_t *sizep, size_t *alignp); SANITIZER_INTERFACE_ATTRIBUTE void __dfsw__dl_get_tls_static_info( size_t *sizep, size_t *alignp, dfsan_label sizep_label, dfsan_label alignp_label) { assert(_dl_get_tls_static_info); _dl_get_tls_static_info(sizep, alignp); dfsan_set_label(0, sizep, sizeof(*sizep)); dfsan_set_label(0, alignp, sizeof(*alignp)); } #endif SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_ctime_r(const time_t *timep, char *buf, dfsan_label timep_label, dfsan_label buf_label, dfsan_label *ret_label) { char *ret = ctime_r(timep, buf); if (ret) { dfsan_set_label(dfsan_read_label(timep, sizeof(time_t)), buf, strlen(buf) + 1); *ret_label = buf_label; } else { *ret_label = 0; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_getcwd(char *buf, size_t size, dfsan_label buf_label, dfsan_label size_label, dfsan_label *ret_label) { char *ret = getcwd(buf, size); if (ret) { dfsan_set_label(0, ret, strlen(ret) + 1); *ret_label = buf_label; } else { *ret_label = 0; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_get_current_dir_name(dfsan_label *ret_label) { char *ret = get_current_dir_name(); if (ret) { dfsan_set_label(0, ret, strlen(ret) + 1); } *ret_label = 0; return ret; } #if __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 25 // This function is only available for glibc 2.25 or newer. Mark it weak so // linking succeeds with older glibcs. SANITIZER_WEAK_ATTRIBUTE int getentropy(void *buffer, size_t length); SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_getentropy(void *buffer, size_t length, dfsan_label buffer_label, dfsan_label length_label, dfsan_label *ret_label) { int ret = getentropy(buffer, length); if (ret == 0) { dfsan_set_label(0, buffer, length); } *ret_label = 0; return ret; } #endif SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_gethostname(char *name, size_t len, dfsan_label name_label, dfsan_label len_label, dfsan_label *ret_label) { int ret = gethostname(name, len); if (ret == 0) { dfsan_set_label(0, name, strlen(name) + 1); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_getpeername( int sockfd, struct sockaddr *addr, socklen_t *addrlen, dfsan_label sockfd_label, dfsan_label addr_label, dfsan_label addrlen_label, dfsan_label *ret_label) { socklen_t origlen = addrlen ? *addrlen : 0; int ret = getpeername(sockfd, addr, addrlen); if (ret != -1 && addr && addrlen) { socklen_t written_bytes = origlen < *addrlen ? origlen : *addrlen; dfsan_set_label(0, addrlen, sizeof(*addrlen)); dfsan_set_label(0, addr, written_bytes); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_getrlimit(int resource, struct rlimit *rlim, dfsan_label resource_label, dfsan_label rlim_label, dfsan_label *ret_label) { int ret = getrlimit(resource, rlim); if (ret == 0) { dfsan_set_label(0, rlim, sizeof(struct rlimit)); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_getrusage(int who, struct rusage *usage, dfsan_label who_label, dfsan_label usage_label, dfsan_label *ret_label) { int ret = getrusage(who, usage); if (ret == 0) { dfsan_set_label(0, usage, sizeof(struct rusage)); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_getsockname( int sockfd, struct sockaddr *addr, socklen_t *addrlen, dfsan_label sockfd_label, dfsan_label addr_label, dfsan_label addrlen_label, dfsan_label *ret_label) { socklen_t origlen = addrlen ? *addrlen : 0; int ret = getsockname(sockfd, addr, addrlen); if (ret != -1 && addr && addrlen) { socklen_t written_bytes = origlen < *addrlen ? origlen : *addrlen; dfsan_set_label(0, addrlen, sizeof(*addrlen)); dfsan_set_label(0, addr, written_bytes); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_getsockopt( int sockfd, int level, int optname, void *optval, socklen_t *optlen, dfsan_label sockfd_label, dfsan_label level_label, dfsan_label optname_label, dfsan_label optval_label, dfsan_label optlen_label, dfsan_label *ret_label) { int ret = getsockopt(sockfd, level, optname, optval, optlen); if (ret != -1 && optval && optlen) { dfsan_set_label(0, optlen, sizeof(*optlen)); dfsan_set_label(0, optval, *optlen); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_nanosleep(const struct timespec *req, struct timespec *rem, dfsan_label req_label, dfsan_label rem_label, dfsan_label *ret_label) { int ret = nanosleep(req, rem); *ret_label = 0; if (ret == -1) { // Interrupted by a signal, rem is filled with the remaining time. dfsan_set_label(0, rem, sizeof(struct timespec)); } return ret; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_stpcpy(char *dest, const char *src, dfsan_label dest_label, dfsan_label src_label, dfsan_label *ret_label) { size_t len = strlen(src) + 1; __taint_check_bounds(dest_label, (uptr)dest, 0, len); char *ret = stpcpy(dest, src); if (ret) { internal_memcpy(shadow_for(dest), shadow_for(src), sizeof(dfsan_label) * len); } *ret_label = dest_label; return ret; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strcpy(char *dest, const char *src, dfsan_label dst_label, dfsan_label src_label, dfsan_label *ret_label) { size_t len = strlen(src) + 1; __taint_check_bounds(dst_label, (uptr)dest, 0, len); char *ret = strcpy(dest, src); *ret_label = dst_label; // Use get_str_label to properly get the source label // This handles str_map, pointer label string ops, and buffer content dfsan_label real_src_label = get_str_label(src, src_label); AOUT("strcpy: src='%p', src_label=%d, real_src_label=%d\n", src, src_label, real_src_label); if (real_src_label != 0) { // Store the label in runtime map keyed by destination address taint_set_str_content_label(dest, real_src_label); *ret_label = real_src_label; } if (ret) { internal_memcpy(shadow_for(dest), shadow_for(src), sizeof(dfsan_label) * len); } return ret; } static dfsan_label taint_strtol(const char *nptr, uptr len, size_t ret_size, int base) { dfsan_label load = 0; if (len > 0) { load = dfsan_read_label(nptr, len); } else { // well, no byte get consumed, handle specially dfsan_label l = shadow_for(nptr)[0]; if (l == 0) // constant return 0; load = dfsan_union(l, 0, Load, 0, 0, 0); } return dfsan_union(0, load, fatoi, sizeof(ret_size) * 8, base, len); } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_atoi(const char *nptr, dfsan_label nptr_label, dfsan_label *ret_label) { char *tmp_endptr; int ret = (int)strtol(nptr, &tmp_endptr, 10); uptr len = (uptr)tmp_endptr - (uptr)nptr; *ret_label = taint_strtol(nptr, len, sizeof(ret), 10); return ret; } SANITIZER_INTERFACE_ATTRIBUTE long __dfsw_atol(const char *nptr, dfsan_label nptr_label, dfsan_label *ret_label) { char *tmp_endptr; long ret = strtol(nptr, &tmp_endptr, 10); uptr len = (uptr)tmp_endptr - (uptr)nptr; *ret_label = taint_strtol(nptr, len, sizeof(ret), 10); return ret; } SANITIZER_INTERFACE_ATTRIBUTE long long __dfsw_atoll(const char *nptr, dfsan_label nptr_label, dfsan_label *ret_label) { char *tmp_endptr; long long ret = strtoll(nptr, &tmp_endptr, 10); uptr len = (uptr)tmp_endptr - (uptr)nptr; *ret_label = taint_strtol(nptr, len, sizeof(ret), 10); return ret; } SANITIZER_INTERFACE_ATTRIBUTE long __dfsw_strtol(const char *nptr, char **endptr, int base, dfsan_label nptr_label, dfsan_label endptr_label, dfsan_label base_label, dfsan_label *ret_label) { char *tmp_endptr; long ret = strtol(nptr, &tmp_endptr, base); if (endptr) { *endptr = tmp_endptr; } uptr len = (uptr)tmp_endptr - (uptr)nptr; *ret_label = taint_strtol(nptr, len, sizeof(ret), base); return ret; } SANITIZER_INTERFACE_ATTRIBUTE double __dfsw_strtod(const char *nptr, char **endptr, dfsan_label nptr_label, dfsan_label endptr_label, dfsan_label *ret_label) { char *tmp_endptr; double ret = strtod(nptr, &tmp_endptr); if (endptr) { *endptr = tmp_endptr; } *ret_label = 0; // TODO: implement return ret; } SANITIZER_INTERFACE_ATTRIBUTE long long __dfsw_strtoll(const char *nptr, char **endptr, int base, dfsan_label nptr_label, dfsan_label endptr_label, dfsan_label base_label, dfsan_label *ret_label) { char *tmp_endptr; long long ret = strtoll(nptr, &tmp_endptr, base); if (endptr) { *endptr = tmp_endptr; } AOUT("strtoll: %s\n", nptr); uptr len = (uptr)tmp_endptr - (uptr)nptr; *ret_label = taint_strtol(nptr, len, sizeof(ret), base); return ret; } SANITIZER_INTERFACE_ATTRIBUTE unsigned long __dfsw_strtoul(const char *nptr, char **endptr, int base, dfsan_label nptr_label, dfsan_label endptr_label, dfsan_label base_label, dfsan_label *ret_label) { char *tmp_endptr; unsigned long ret = strtoul(nptr, &tmp_endptr, base); if (endptr) { *endptr = tmp_endptr; } uptr len = (uptr)tmp_endptr - (uptr)nptr; *ret_label = taint_strtol(nptr, len, sizeof(ret), base); return ret; } SANITIZER_INTERFACE_ATTRIBUTE unsigned long long __dfsw_strtoull(const char *nptr, char **endptr, dfsan_label nptr_label, int base, dfsan_label endptr_label, dfsan_label base_label, dfsan_label *ret_label) { char *tmp_endptr; unsigned long long ret = strtoull(nptr, &tmp_endptr, base); if (endptr) { *endptr = tmp_endptr; } uptr len = (uptr)tmp_endptr - (uptr)nptr; *ret_label = taint_strtol(nptr, len, sizeof(ret), base); return ret; } SANITIZER_INTERFACE_ATTRIBUTE time_t __dfsw_time(time_t *t, dfsan_label t_label, dfsan_label *ret_label) { time_t ret = time(t); if (ret != (time_t) -1 && t) { dfsan_set_label(0, t, sizeof(time_t)); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_inet_pton(int af, const char *src, void *dst, dfsan_label af_label, dfsan_label src_label, dfsan_label dst_label, dfsan_label *ret_label) { int ret = inet_pton(af, src, dst); if (ret == 1) { dfsan_set_label(dfsan_read_label(src, strlen(src) + 1), dst, af == AF_INET ? sizeof(struct in_addr) : sizeof(in6_addr)); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE struct tm *__dfsw_localtime_r(const time_t *timep, struct tm *result, dfsan_label timep_label, dfsan_label result_label, dfsan_label *ret_label) { struct tm *ret = localtime_r(timep, result); if (ret) { dfsan_set_label(dfsan_read_label(timep, sizeof(time_t)), result, sizeof(struct tm)); *ret_label = result_label; } else { *ret_label = 0; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_getpwuid_r(id_t uid, struct passwd *pwd, char *buf, size_t buflen, struct passwd **result, dfsan_label uid_label, dfsan_label pwd_label, dfsan_label buf_label, dfsan_label buflen_label, dfsan_label result_label, dfsan_label *ret_label) { // Store the data in pwd, the strings referenced from pwd in buf, and the // address of pwd in *result. On failure, NULL is stored in *result. int ret = getpwuid_r(uid, pwd, buf, buflen, result); if (ret == 0) { dfsan_set_label(0, pwd, sizeof(struct passwd)); dfsan_set_label(0, buf, strlen(buf) + 1); } *ret_label = 0; dfsan_set_label(0, result, sizeof(struct passwd*)); return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout, dfsan_label epfd_label, dfsan_label events_label, dfsan_label maxevents_label, dfsan_label timeout_label, dfsan_label *ret_label) { int ret = epoll_wait(epfd, events, maxevents, timeout); if (ret > 0) dfsan_set_label(0, events, ret * sizeof(*events)); *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_poll(struct pollfd *fds, nfds_t nfds, int timeout, dfsan_label dfs_label, dfsan_label nfds_label, dfsan_label timeout_label, dfsan_label *ret_label) { int ret = poll(fds, nfds, timeout); if (ret >= 0) { for (; nfds > 0; --nfds) { dfsan_set_label(0, &fds[nfds - 1].revents, sizeof(fds[nfds - 1].revents)); } } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout, dfsan_label nfds_label, dfsan_label readfds_label, dfsan_label writefds_label, dfsan_label exceptfds_label, dfsan_label timeout_label, dfsan_label *ret_label) { int ret = select(nfds, readfds, writefds, exceptfds, timeout); // Clear everything (also on error) since their content is either set or // undefined. if (readfds) { dfsan_set_label(0, readfds, sizeof(fd_set)); } if (writefds) { dfsan_set_label(0, writefds, sizeof(fd_set)); } if (exceptfds) { dfsan_set_label(0, exceptfds, sizeof(fd_set)); } if (timeout) { dfsan_set_label(0, timeout, sizeof(struct timeval)); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask, dfsan_label pid_label, dfsan_label cpusetsize_label, dfsan_label mask_label, dfsan_label *ret_label) { int ret = sched_getaffinity(pid, cpusetsize, mask); if (ret == 0) { dfsan_set_label(0, mask, cpusetsize); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_sigemptyset(sigset_t *set, dfsan_label set_label, dfsan_label *ret_label) { int ret = sigemptyset(set); dfsan_set_label(0, set, sizeof(sigset_t)); *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_sigaction(int signum, const struct sigaction *act, struct sigaction *oldact, dfsan_label signum_label, dfsan_label act_label, dfsan_label oldact_label, dfsan_label *ret_label) { int ret = sigaction(signum, act, oldact); if (oldact) { dfsan_set_label(0, oldact, sizeof(struct sigaction)); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_sigaltstack(const stack_t *ss, stack_t *old_ss, dfsan_label ss_label, dfsan_label old_ss_label, dfsan_label *ret_label) { int ret = sigaltstack(ss, old_ss); if (ret != -1 && old_ss) dfsan_set_label(0, old_ss, sizeof(*old_ss)); *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_gettimeofday(struct timeval *tv, struct timezone *tz, dfsan_label tv_label, dfsan_label tz_label, dfsan_label *ret_label) { int ret = gettimeofday(tv, tz); if (tv) { dfsan_set_label(0, tv, sizeof(struct timeval)); } if (tz) { dfsan_set_label(0, tz, sizeof(struct timezone)); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_memchr(void *s, int c, size_t n, dfsan_label s_label, dfsan_label c_label, dfsan_label n_label, dfsan_label *ret_label) { void *ret = memchr(s, c, n); // Use unified get_str_label_n for source label // Pass n_label to handle fsubstr creation when n derives from a string op dfsan_label src_label = get_str_label_n(s, s_label, n, n_label); if (src_label != 0 || c_label != 0) { // Determine which operand is concrete and set size accordingly uint16_t content_len = (src_label == 0) ? (uint16_t)n : 0; // l1 = src_label (haystack content) // l2 = c_label (character to find) // op1 = haystack pointer (for concrete content retrieval) // op2 = character value // size = haystack length if haystack concrete, else 0 *ret_label = dfsan_union(src_label, c_label, __dfsan::fstrchr, content_len, (uint64_t)s, (uint64_t)(uint8_t)c); // Send concrete content if haystack is concrete if (content_len > 0 && *ret_label) { __taint_trace_memcmp(*ret_label); } // Store the result pointer to recover symbolic length if (ret) { taint_set_str_indexof_label(ret, *ret_label); } } else { *ret_label = 0; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strrchr(char *s, int c, dfsan_label s_label, dfsan_label c_label, dfsan_label *ret_label) { char *ret = strrchr(s, c); // Use unified get_str_label for source label dfsan_label src_label = get_str_label(s, s_label); if (src_label != 0 || c_label != 0) { // Determine which operand is concrete and set size accordingly size_t haystack_len = strlen(s); uint16_t content_len = (src_label == 0) ? (uint16_t)haystack_len : 0; // l1 = src_label (source - for chaining or content dependencies) // l2 = c_label (target char - may be symbolic!) // op1 = haystack pointer (for concrete content retrieval) // op2 = char value // size = haystack length if concrete, else 0 *ret_label = dfsan_union(src_label, c_label, __dfsan::fstrrchr, content_len, (uint64_t)s, (uint64_t)(uint8_t)c); // Send concrete haystack content if haystack is concrete if (content_len > 0 && *ret_label) { __taint_trace_memcmp(*ret_label); } // Store the result pointer to recover symbolic length if (ret) { taint_set_str_indexof_label(ret, *ret_label); } } else { *ret_label = 0; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_memrchr(const void *s, int c, size_t n, dfsan_label s_label, dfsan_label c_label, dfsan_label n_label, dfsan_label *ret_label) { void *ret = const_cast(memrchr(s, c, n)); // Use unified get_str_label_n for source label // Pass n_label to handle fsubstr creation when n derives from a string op dfsan_label src_label = get_str_label_n(s, s_label, n, n_label); if (src_label != 0 || c_label != 0) { // Determine which operand is concrete and set size accordingly uint16_t content_len = (src_label == 0) ? (uint16_t)n : 0; // l1 = src_label (haystack content) // l2 = c_label (character to find) // op1 = haystack pointer (for concrete content retrieval) // op2 = character value // size = haystack length if haystack concrete, else 0 *ret_label = dfsan_union(src_label, c_label, __dfsan::fstrrchr, content_len, (uint64_t)s, (uint64_t)(uint8_t)c); // Send concrete content if haystack is concrete if (content_len > 0 && *ret_label) { __taint_trace_memcmp(*ret_label); } // Store the result pointer to recover symbolic length if (ret) { taint_set_str_indexof_label(ret, *ret_label); } } else { *ret_label = 0; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strstr(char *haystack, char *needle, dfsan_label haystack_label, dfsan_label needle_label, dfsan_label *ret_label) { char *ret = strstr(haystack, needle); // Use unified get_str_label for haystack and needle dfsan_label src_label = get_str_label(haystack, haystack_label); dfsan_label real_needle_label = get_str_label(needle, needle_label); if (src_label != 0 || real_needle_label != 0) { // Determine which operand is concrete and set size accordingly size_t haystack_len = strlen(haystack); size_t needle_len = strlen(needle); uint16_t content_len = 0; if (src_label == 0) { content_len = (uint16_t)haystack_len; } else if (real_needle_label == 0) { content_len = (uint16_t)needle_len; } // l1 = src_label (source - for chaining or content dependencies) // l2 = real_needle_label (may be symbolic string!) // op1 = haystack pointer (for concrete content retrieval) // op2 = needle pointer (for concrete content retrieval) // size = haystack length if haystack concrete, else needle length if needle concrete, else 0 dfsan_label label = dfsan_union(src_label, real_needle_label, __dfsan::fstrstr, content_len, (uint64_t)haystack, (uint64_t)needle); // Send concrete content (haystack or needle) if (content_len > 0 && label) { __taint_trace_memcmp(label); } *ret_label = label; // Store the result pointer to recover symbolic length if (ret) { taint_set_str_indexof_label(ret, *ret_label); } } else { *ret_label = 0; } return ret; } // strnstr implementation (BSD function not available on Linux) static char *strnstr_impl(const char *haystack, const char *needle, size_t len) { size_t needle_len = strlen(needle); if (needle_len == 0) return (char *)haystack; if (len == 0) return NULL; for (size_t i = 0; i < len && haystack[i]; i++) { if (i + needle_len > len) break; if (strncmp(haystack + i, needle, needle_len) == 0) return (char *)(haystack + i); } return NULL; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_strnstr(char *haystack, char *needle, size_t len, dfsan_label haystack_label, dfsan_label needle_label, dfsan_label len_label, dfsan_label *ret_label) { char *ret = strnstr_impl(haystack, needle, len); // Use unified get_str_label_n for haystack (respects length parameter) dfsan_label src_label = get_str_label_n(haystack, haystack_label, strnlen(haystack, len), len_label); // Use unified get_str_label for needle dfsan_label real_needle_label = get_str_label(needle, needle_label); if (src_label != 0 || real_needle_label != 0) { // Determine which operand is concrete and set size accordingly size_t haystack_len = strnlen(haystack, len); size_t needle_len = strlen(needle); uint16_t content_len = 0; if (src_label == 0) { content_len = (uint16_t)haystack_len; } else if (real_needle_label == 0) { content_len = (uint16_t)needle_len; } // l1 = src_label (source - for chaining or content dependencies) // l2 = real_needle_label (may be symbolic string!) // op1 = haystack pointer (for concrete content retrieval) // op2 = needle pointer (for concrete content retrieval) // size = haystack length if haystack concrete, else needle length if needle concrete, else 0 dfsan_label label = dfsan_union(src_label, real_needle_label, __dfsan::fstrstr, content_len, (uint64_t)haystack, (uint64_t)needle); // Send concrete content (haystack or needle) if (content_len > 0 && label) { __taint_trace_memcmp(label); } *ret_label = label; // Store the result pointer to recover symbolic length if (ret) { taint_set_str_indexof_label(ret, *ret_label); } } else { *ret_label = 0; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_memmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen, dfsan_label haystack_label, dfsan_label haystacklen_label, dfsan_label needle_label, dfsan_label needlelen_label, dfsan_label *ret_label) { void *ret = memmem(haystack, haystacklen, needle, needlelen); // Use unified get_str_label_n for haystack and needle // Pass haystacklen_label to handle fsubstr creation when haystacklen derives from a string op dfsan_label src_label = get_str_label_n(haystack, haystack_label, haystacklen, haystacklen_label); // Use unified get_str_label_n for needle dfsan_label real_needle_label = get_str_label_n(needle, needle_label, needlelen, needlelen_label); if (src_label != 0 || real_needle_label != 0) { // Determine which operand is concrete and set size accordingly uint16_t content_len = 0; if (src_label == 0) { content_len = (uint16_t)haystacklen; } else if (real_needle_label == 0) { content_len = (uint16_t)needlelen; } // l1 = src_label (haystack content) // l2 = real_needle_label (needle content - may be symbolic!) // op1 = haystack pointer (for concrete content retrieval) // op2 = needle pointer (for concrete content retrieval) // size = haystack length if haystack concrete, else needle length if needle concrete, else 0 dfsan_label label = dfsan_union(src_label, real_needle_label, __dfsan::fstrstr, content_len, (uint64_t)haystack, (uint64_t)needle); // Send concrete content (haystack or needle) if (content_len > 0 && label) { __taint_trace_memcmp(label); } *ret_label = label; // Store the result pointer to recover symbolic length if (ret) { taint_set_str_indexof_label(ret, *ret_label); } } else { *ret_label = 0; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_connect( int sockfd, const struct sockaddr *addr, socklen_t addrlen, dfsan_label sockfd_label, dfsan_label addr_label, dfsan_label addrlen_label, dfsan_label *ret_label) { int ret = connect(sockfd, addr, addrlen); if (ret == 0 || errno == EINPROGRESS || errno == EALREADY) { taint_set_socket(addr, addrlen, sockfd); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE ssize_t __dfsw_recv( int sockfd, void *buf, size_t leng, int flags, dfsan_label sockfd_label, dfsan_label buf_label, dfsan_label leng_label, dfsan_label flags_label, dfsan_label *ret_label) { __taint_check_bounds(buf_label, (uptr)buf, leng_label, leng); if (leng_label) __taint_solve_bounds(buf_label, (uint64_t)buf, leng_label, leng, 0, 1, 0, 0); internal_memset(buf, 0, leng); ssize_t ret = recv(sockfd, buf, leng, flags); #if AIXCC_HACK ssize_t readed = strlen((char *)buf); if (ret == 0 && readed > 0) ret = readed; // we actually readed something #endif if (ret > 0) { off_t offset = taint_get_socket(sockfd); if (offset >= 0) { AOUT("recv: fd = %d, offset = %ld, ret = %ld\n", sockfd, offset, ret); for (ssize_t i = 0; i < ret; i++) { dfsan_set_label(dfsan_create_label(offset + i), (char *)buf + i, 1); } taint_update_socket_offset(sockfd, ret); } else { // clear the label? dfsan_set_label(0, buf, ret); } } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE ssize_t __dfsw_recvfrom( int sockfd, void *buf, size_t leng, int flags, struct sockaddr *src_addr, socklen_t *addrlen, dfsan_label sockfd_label, dfsan_label buf_label, dfsan_label leng_label, dfsan_label flags_label, dfsan_label src_addr_label, dfsan_label addrlen_label, dfsan_label *ret_label) { socklen_t alen = 0; __taint_check_bounds(buf_label, (uptr)buf, leng_label, leng); if (leng_label) __taint_solve_bounds(buf_label, (uint64_t)buf, leng_label, leng, 0, 1, 0, 0); internal_memset(buf, 0, leng); ssize_t ret = recvfrom(sockfd, buf, leng, flags, src_addr, &alen); #if AIXCC_HACK ssize_t readed = strlen((char *)buf); if (ret == 0 && readed > 0) ret = readed; // we actually readed something #endif if (ret > 0) { off_t offset = taint_get_socket(sockfd); if (offset >= 0) { for (ssize_t i = 0; i < ret; i++) { dfsan_set_label(dfsan_create_label(offset + i), (char *)buf + i, 1); } taint_update_socket_offset(sockfd, ret); } else { // clear the label? dfsan_set_label(0, buf, ret); } } if (src_addr) { dfsan_set_label(0, src_addr, alen); } if (addrlen) { *addrlen = alen; } *ret_label = 0; return ret; } static void taint_handle_msg(int sockfd, struct msghdr *msg, size_t msg_len) { // clear labels if (msg->msg_name) { dfsan_set_label(0, msg->msg_name, msg->msg_namelen); } if (msg->msg_control) { dfsan_set_label(0, msg->msg_control, msg->msg_controllen); } off_t offset = taint_get_socket(sockfd); for (size_t i = 0, bytes_written = msg_len; bytes_written > 0; ++i) { assert(i < msg->msg_iovlen); struct iovec *iov = &msg->msg_iov[i]; size_t iov_written = bytes_written < iov->iov_len ? bytes_written : iov->iov_len; if (offset >= 0) { for (size_t j = 0; j < iov_written; ++j) { dfsan_set_label(dfsan_create_label(offset + j), (char *)iov->iov_base + j, 1); } taint_update_socket_offset(sockfd, iov_written); offset += iov_written; } else { dfsan_set_label(0, iov->iov_base, iov_written); } bytes_written -= iov_written; } } SANITIZER_INTERFACE_ATTRIBUTE ssize_t __dfsw_recvmsg( int sockfd, struct msghdr *msg, int flags, dfsan_label sockfd_label, dfsan_label msg_label, dfsan_label flags_label, dfsan_label *ret_label) { ssize_t ret = recvmsg(sockfd, msg, flags); if (ret >= 0) { taint_handle_msg(sockfd, msg, ret); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_recvmmsg( int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, struct timespec *timeout, dfsan_label sockfd_label, dfsan_label msgvec_label, dfsan_label vlen_label, dfsan_label flags_label, dfsan_label timeout_label, dfsan_label *ret_label) { int ret = recvmmsg(sockfd, msgvec, vlen, flags, timeout); for (int i = 0; i < ret; ++i) { dfsan_set_label(0, &msgvec[i].msg_len, sizeof(msgvec[i].msg_len)); taint_handle_msg(sockfd, &msgvec[i].msg_hdr, msgvec[i].msg_len); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_socketpair(int domain, int type, int protocol, int sv[2], dfsan_label domain_label, dfsan_label type_label, dfsan_label protocol_label, dfsan_label sv_label, dfsan_label *ret_label) { int ret = socketpair(domain, type, protocol, sv); *ret_label = 0; if (ret == 0) { dfsan_set_label(0, sv, sizeof(*sv) * 2); } return ret; } // Type of the trampoline function passed to the custom version of // dfsan_set_write_callback. typedef void (*write_trampoline_t)( void *callback, int fd, const void *buf, ssize_t count, dfsan_label fd_label, dfsan_label buf_label, dfsan_label count_label); // Calls to dfsan_set_write_callback() set the values in this struct. // Calls to the custom version of write() read (and invoke) them. static struct { write_trampoline_t write_callback_trampoline = nullptr; void *write_callback = nullptr; } write_callback_info; SANITIZER_INTERFACE_ATTRIBUTE void __dfsw_dfsan_set_write_callback( write_trampoline_t write_callback_trampoline, void *write_callback, dfsan_label write_callback_label, dfsan_label *ret_label) { write_callback_info.write_callback_trampoline = write_callback_trampoline; write_callback_info.write_callback = write_callback; *ret_label = 0; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_write(int fd, const void *buf, size_t count, dfsan_label fd_label, dfsan_label buf_label, dfsan_label count_label, dfsan_label *ret_label) { if (write_callback_info.write_callback) { write_callback_info.write_callback_trampoline( write_callback_info.write_callback, fd, buf, count, fd_label, buf_label, count_label); } *ret_label = 0; int ret = write(fd, buf, count); #if AIXCC_HACK if (buf && tainted.buf && !internal_memcmp(buf, tainted.buf, count)) { AOUT("Closing aixcc pipefd %d\n", fd); close(fd); } #endif return ret; } } // extern "C" // Type used to extract a dfsan_label with va_arg() typedef int dfsan_label_va; // Formats a chunk either a constant string or a single format directive (e.g., // '%.3f'). struct Formatter { Formatter(char *str_, const char *fmt_, size_t size_) : str(str_), str_off(0), size(size_), fmt_start(fmt_), fmt_cur(fmt_), width(-1) {} int format() { char *tmp_fmt = build_format_string(); int retval = snprintf(str + str_off, str_off < size ? size - str_off : 0, tmp_fmt, 0 /* used only to avoid warnings */); free(tmp_fmt); return retval; } template int format(T arg) { char *tmp_fmt = build_format_string(); int retval; if (width >= 0) { retval = snprintf(str + str_off, str_off < size ? size - str_off : 0, tmp_fmt, width, arg); } else { retval = snprintf(str + str_off, str_off < size ? size - str_off : 0, tmp_fmt, arg); } free(tmp_fmt); return retval; } char *build_format_string() { size_t fmt_size = fmt_cur - fmt_start + 1; char *new_fmt = (char *)malloc(fmt_size + 1); assert(new_fmt); internal_memcpy(new_fmt, fmt_start, fmt_size); new_fmt[fmt_size] = '\0'; return new_fmt; } char *str_cur() { return str + str_off; } size_t num_written_bytes(int retval) { if (retval < 0) { return 0; } size_t num_avail = str_off < size ? size - str_off : 0; if (num_avail == 0) { return 0; } size_t num_written = retval; // A return value of {v,}snprintf of size or more means that the output was // truncated. if (num_written >= num_avail) { num_written -= num_avail; } return num_written; } char *str; size_t str_off; size_t size; const char *fmt_start; const char *fmt_cur; int width; }; // Formats the input and propagates the input labels to the output. The output // is stored in 'str'. 'size' bounds the number of output bytes. 'format' and // 'ap' are the format string and the list of arguments for formatting. Returns // the return value vsnprintf would return. // // The function tokenizes the format string in chunks representing either a // constant string or a single format directive (e.g., '%.3f') and formats each // chunk independently into the output string. This approach allows to figure // out which bytes of the output string depends on which argument and thus to // propagate labels more precisely. // // WARNING: This implementation does not support conversion specifiers with // positional arguments. static int format_buffer(char *str, size_t size, const char *fmt, dfsan_label *va_labels, dfsan_label *ret_label, va_list ap) { Formatter formatter(str, fmt, size); while (*formatter.fmt_cur) { formatter.fmt_start = formatter.fmt_cur; formatter.width = -1; int retval = 0; if (*formatter.fmt_cur != '%') { // Ordinary character. Consume all the characters until a '%' or the end // of the string. for (; *(formatter.fmt_cur + 1) && *(formatter.fmt_cur + 1) != '%'; ++formatter.fmt_cur) {} retval = formatter.format(); dfsan_set_label(0, formatter.str_cur(), formatter.num_written_bytes(retval)); } else { // Conversion directive. Consume all the characters until a conversion // specifier or the end of the string. bool end_fmt = false; for (; *formatter.fmt_cur && !end_fmt; ) { switch (*++formatter.fmt_cur) { case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': switch (*(formatter.fmt_cur - 1)) { case 'h': // Also covers the 'hh' case (since the size of the arg is still // an int). retval = formatter.format(va_arg(ap, int)); break; case 'l': if (formatter.fmt_cur - formatter.fmt_start >= 2 && *(formatter.fmt_cur - 2) == 'l') { retval = formatter.format(va_arg(ap, long long int)); } else { retval = formatter.format(va_arg(ap, long int)); } break; case 'q': retval = formatter.format(va_arg(ap, long long int)); break; case 'j': retval = formatter.format(va_arg(ap, intmax_t)); break; case 'z': case 't': retval = formatter.format(va_arg(ap, size_t)); break; default: retval = formatter.format(va_arg(ap, int)); } //dfsan_set_label(*va_labels++, formatter.str_cur(), // formatter.num_written_bytes(retval)); end_fmt = true; break; case 'a': case 'A': case 'e': case 'E': case 'f': case 'F': case 'g': case 'G': if (*(formatter.fmt_cur - 1) == 'L') { retval = formatter.format(va_arg(ap, long double)); } else { retval = formatter.format(va_arg(ap, double)); } //dfsan_set_label(*va_labels++, formatter.str_cur(), // formatter.num_written_bytes(retval)); end_fmt = true; break; case 'c': retval = formatter.format(va_arg(ap, int)); //dfsan_set_label(*va_labels++, formatter.str_cur(), // formatter.num_written_bytes(retval)); end_fmt = true; break; case 's': { char *arg = va_arg(ap, char *); retval = formatter.format(arg); va_labels++; internal_memcpy(shadow_for(formatter.str_cur()), shadow_for(arg), sizeof(dfsan_label) * formatter.num_written_bytes(retval)); end_fmt = true; break; } case 'p': retval = formatter.format(va_arg(ap, void *)); //dfsan_set_label(*va_labels++, formatter.str_cur(), // formatter.num_written_bytes(retval)); end_fmt = true; break; case 'n': { int *ptr = va_arg(ap, int *); *ptr = (int)formatter.str_off; va_labels++; dfsan_set_label(0, ptr, sizeof(ptr)); end_fmt = true; break; } case '%': retval = formatter.format(); dfsan_set_label(0, formatter.str_cur(), formatter.num_written_bytes(retval)); end_fmt = true; break; case '*': formatter.width = va_arg(ap, int); va_labels++; break; default: break; } } } if (retval < 0) { return retval; } formatter.fmt_cur++; formatter.str_off += retval; } *ret_label = 0; // Number of bytes written in total. return formatter.str_off; } extern "C" { SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_sprintf(char *str, const char *format, dfsan_label str_label, dfsan_label format_label, dfsan_label *va_labels, dfsan_label *ret_label, ...) { va_list ap; va_start(ap, ret_label); int ret = format_buffer(str, ~0ul, format, va_labels, ret_label, ap); va_end(ap); *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_snprintf(char *str, size_t size, const char *format, dfsan_label str_label, dfsan_label size_label, dfsan_label format_label, dfsan_label *va_labels, dfsan_label *ret_label, ...) { va_list ap; va_start(ap, ret_label); int ret = format_buffer(str, size, format, va_labels, ret_label, ap); va_end(ap); *ret_label = 0; return ret; } // Default empty implementations (weak). Users should redefine them. SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard, u32 *) {} SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard_init, u32 *, u32 *) {} SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_pcs_init, const uptr *beg, const uptr *end) {} SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_indir, void) {} SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp, void) {} SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp1, void) {} SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp2, void) {} SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp4, void) {} SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_cmp8, void) {} SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_const_cmp1, void) {} SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_const_cmp2, void) {} SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_const_cmp4, void) {} SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_const_cmp8, void) {} SANITIZER_INTERFACE_WEAK_DEF(void, __dfsw___sanitizer_cov_trace_switch, void) {} SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_open(const char *path, int oflags, dfsan_label path_label, dfsan_label flag_label, dfsan_label *va_labels, dfsan_label *ret_label, ...) { va_list args; va_start(args, ret_label); int fd = open(path, oflags, args); va_end(args); if (fd) taint_set_file(AT_FDCWD, path, fd); *ret_label = 0; return fd; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_openat(int dirfd, const char *path, int oflags, dfsan_label dirfd_label, dfsan_label path_label, dfsan_label flag_label, dfsan_label *va_labels, dfsan_label *ret_label, ...) { va_list args; va_start(args, ret_label); int fd = openat(dirfd, path, oflags, args); va_end(args); if (fd) taint_set_file(dirfd, path, fd); *ret_label = 0; return fd; } SANITIZER_INTERFACE_ATTRIBUTE FILE * __dfsw_fopen(const char *filename, const char *mode, dfsan_label filename_label, dfsan_label mode_label, dfsan_label *ret_label) { FILE *ret = fopen(filename, mode); if (ret) { AOUT("%d fd is fopened\n", fileno(ret)); taint_set_file(AT_FDCWD, filename, fileno(ret)); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE FILE * __dfsw_fopen64(const char *filename, const char *mode, dfsan_label filename_label, dfsan_label mode_label, dfsan_label *ret_label) { FILE *ret = fopen64(filename, mode); if (ret) { AOUT("%d fd is fopened\n", fileno(ret)); taint_set_file(AT_FDCWD, filename, fileno(ret)); } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE FILE * __dfsw_freopen(const char *filename, const char *mode, FILE *stream, dfsan_label filename_label, dfsan_label mode_label, dfsan_label stream_label, dfsan_label *ret_label) { FILE *ret = freopen(filename, mode, stream); if (ret) taint_set_file(AT_FDCWD, filename, fileno(ret)); *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_close(int fd, dfsan_label fd_label, dfsan_label *ret_label) { taint_close_file(fd); *ret_label = 0; return close(fd); } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_fclose(FILE *fp, dfsan_label fp_label, dfsan_label *ret_label) { int fd = fileno(fp); int ret = fclose(fp); if (!ret) taint_close_file(fd); *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE size_t __dfsw_fread(void *ptr, size_t size, size_t nmemb, FILE *stream, dfsan_label ptr_label, dfsan_label size_label, dfsan_label nmemb_label, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t tfsize = taint_get_file(fd); off_t offset = ftell(stream); *ret_label = 0; #if 0 // check taint file size if (tfsize && (tfsize < offset + (size * nmemb))) { // if smaller than a tainted offset, enlarge dfsan_label offset_label = taint_get_offset_label(); if (offset_label) { AOUT("fread(%u,%u) from tainted offset %lld\n", size, nmemb, offset); // instead of read, write internal_memset(ptr, 0, size * nmemb); fwrite(ptr, size, nmemb, stream); // update taint for (size_t i = 0; i < size * nmemb; i++) { dfsan_set_label(dfsan_create_label(offset + i), (char *)ptr + i, 1); } return nmemb; // directly return } } #endif __taint_check_bounds(ptr_label, (uptr)ptr, nmemb_label, size * nmemb); if (nmemb_label) __taint_solve_bounds(ptr_label, (uint64_t)ptr, nmemb_label, nmemb, 0, size, 0, 0); size_t ret = fread(ptr, size, nmemb, stream); AOUT("fread(%lu,%lu) = %ld, off = %ld\n", size, nmemb, ret, offset); if (ret) { if (tfsize) { for (size_t i = 0; i < ret * size; i++) { dfsan_set_label(get_label_for(fd, offset + i), (char *)ptr + i, 1); } // for (size_t i = ret * size; i < size * nmemb; i++) { // dfsan_set_label(-1, (char *)ptr + i, 1); // } // *ret_label = dfsan_union(0, 0, fsize, sizeof(ret) * 8, offset, 0); } else { dfsan_set_label(0, ptr, ret * size); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE size_t __dfsw_fread_unlocked( void *ptr, size_t size, size_t nmemb, FILE *stream, dfsan_label ptr_label, dfsan_label size_label, dfsan_label nmemb_label, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t tfsize = taint_get_file(fd); off_t offset = ftell(stream); *ret_label = 0; #if 0 // check taint file size if (tfsize && (tfsize < offset + (size * nmemb))) { // if smaller than a tainted offset, enlarge dfsan_label offset_label = taint_get_offset_label(); if (offset_label) { AOUT("fread(%u,%u) from tainted offset %lld\n", size, nmemb, offset); // instead of read, write internal_memset(ptr, 0, size * nmemb); fwrite(ptr, size, nmemb, stream); // update taint for (size_t i = 0; i < size * nmemb; i++) { dfsan_set_label(dfsan_create_label(offset + i), (char *)ptr + i, 1); } return nmemb; // directly return } } #endif __taint_check_bounds(ptr_label, (uptr)ptr, nmemb_label, size * nmemb); if (nmemb_label) __taint_solve_bounds(ptr_label, (uint64_t)ptr, nmemb_label, nmemb, 0, size, 0, 0); size_t ret = fread_unlocked(ptr, size, nmemb, stream); AOUT("fread(%lu,%lu) = %ld, off = %ld\n", size, nmemb, ret, offset); if (ret) { if (tfsize) { for (size_t i = 0; i < ret * size; i++) { dfsan_set_label(get_label_for(fd, offset + i), (char *)ptr + i, 1); } // for (size_t i = ret * size; i < nmemb * size; i++) { // dfsan_set_label(-1, (char *)ptr + i, 1); // } // *ret_label = dfsan_union(0, 0, fsize, sizeof(ret) * 8, offset, 0); } else { dfsan_set_label(0, ptr, ret * size); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE ssize_t __dfsw_getline(char **lineptr, size_t *n, FILE *stream, dfsan_label lineptr_label, dfsan_label n_label, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t offset = ftell(stream); ssize_t ret = getline(lineptr, n, stream); *ret_label = 0; if (ret) { if (taint_get_file(fd)) { // including a terminating null byte for (ssize_t i = 0; i < ret; i++) { void *addr = (*lineptr) + i; dfsan_set_label(get_label_for(fd, offset + i), addr, 1); } dfsan_set_label(0, (*lineptr) + ret, 1); // *ret_label = dfsan_union(0, 0, fsize, sizeof(ret) * 8, offset, 0); // FIXME: set the label for the ptr to track the buffer size } else { dfsan_set_label(0, *lineptr, ret + 1); } } return ret; } // ssize_t getdelim(char **lineptr, size_t *n, int delim, FILE *stream); SANITIZER_INTERFACE_ATTRIBUTE ssize_t __dfsw_getdelim(char **lineptr, size_t *n, int delim, FILE *stream, dfsan_label buf_label, dfsan_label size_label, dfsan_label delim_label, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t offset = ftell(stream); ssize_t ret = getdelim(lineptr, n, delim, stream); *ret_label = 0; if (ret) { if (taint_get_file(fd)) { // including a terminating null byte for(ssize_t i = 0; i < ret; i++) { void *addr = (*lineptr) + i; dfsan_set_label(get_label_for(fd, offset + i), addr, 1); // FIXME: set the label for the ptr to track the buffer size } dfsan_set_label(0, (*lineptr) + ret, 1); // *ret_label = dfsan_union(0, 0, fsize, sizeof(ret) * 8, offset, 0); } else { dfsan_set_label(0, *lineptr, ret + 1); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE ssize_t __dfsw___getdelim(char **lineptr, size_t *n, int delim, FILE *stream, dfsan_label buf_label, dfsan_label size_label, dfsan_label delim_label, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t offset = ftell(stream); ssize_t ret = __getdelim(lineptr, n, delim, stream); *ret_label = 0; if (ret) { if (taint_get_file(fd)) { for(ssize_t i = 0; i < ret; i++) { void *addr = (*lineptr) + i; dfsan_set_label(get_label_for(fd, offset + i), addr, 1); } dfsan_set_label(0, (*lineptr) + ret, 1); // *ret_label = dfsan_union(0, 0, fsize, sizeof(ret) * 8, offset, 0); // FIXME: set the label for the ptr to track the buffer size } else { dfsan_set_label(0, *lineptr, ret + 1); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE char* __dfsw_gets(char *str, dfsan_label str_label, dfsan_label *ret_label) { off_t offset = ftell(stdin); // gets discard until c11 char *ret = fgets(str, sizeof(str), stdin); if (ret && taint_get_file(0)) { for (off_t i = 0; i <= strlen(ret); i++) dfsan_set_label(get_label_for(0, offset + i), ret + i, 1); *ret_label = str_label; } else { *ret_label = 0; } return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_utmpxname(const char *file, dfsan_label file_label, dfsan_label *ret_label) { if (is_taint_file(file)) { set_utmp_offset(0); } int ret = utmpxname(file); *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE void __dfsw_setutxent(void) { if (is_utmp_taint()) set_utmp_offset(0); setutxent(); } SANITIZER_INTERFACE_ATTRIBUTE struct utmpx * __dfsw_getutxent(dfsan_label *ret_label) { struct utmpx *ret = getutxent(); *ret_label = 0; if (ret && is_utmp_taint()) { off_t offset = get_utmp_offset(); for (size_t i = 0; i < sizeof(struct utmpx); i++) { dfsan_set_label(get_label_for(-1, offset + i), (char *)ret + i, 1); } set_utmp_offset(offset + sizeof(struct utmpx)); } return ret; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_fgets(char *s, int size, FILE *stream, dfsan_label s_label, dfsan_label size_label, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t offset = ftell(stream); __taint_check_bounds(s_label, (uptr)s, size_label, size); if (size_label) __taint_solve_bounds(s_label, (uint64_t)s, size_label, size, 0, 1, 0, 0); char *ret = fgets(s, size, stream); if (ret) { if (taint_get_file(fd)) { // including terminating \0 for (size_t i = 0; i < strlen(ret); i++) { char *buf = s + i; dfsan_set_label(get_label_for(fd, offset + i), buf, 1); } dfsan_set_label(0, s + strlen(ret), 1); // for(int i = strlen(ret) + 1; i < size; i++) { // char *buf = s + i; // dfsan_set_label(-1, buf, 1); // } } else { dfsan_set_label(0, s, strlen(ret) + 1); } *ret_label = s_label; } else *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE char *__dfsw_fgets_unlocked(char *s, int size, FILE *stream, dfsan_label s_label, dfsan_label size_label, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t offset = ftell(stream); __taint_check_bounds(s_label, (uptr)s, size_label, size); if (size_label) __taint_solve_bounds(s_label, (uint64_t)s, size_label, size, 0, 1, 0, 0); char *ret = fgets_unlocked(s, size, stream); if (ret) { if (taint_get_file(fd)) { // including terminating \0 for (size_t i = 0; i < strlen(ret); i++) { char *buf = s + i; dfsan_set_label(get_label_for(fd, offset + i), buf, 1); } dfsan_set_label(0, s + strlen(ret), 1); // for(int i = strlen(ret) + 1; i < size; i++) { // char *buf = s + i; // dfsan_set_label(-1, buf, 1); // } } else { dfsan_set_label(0, s, strlen(ret) + 1); } *ret_label = s_label; } else { *ret_label = 0; } return ret; } static inline void __taint_check_malloc_size(size_t size, dfsan_label size_label) { if (size_label && flags().solve_ub) { AOUT("*alloc size: %lu = %d\n", size, size_label); // -fsanitize=unsigned-integer-overflow dfsan_label os = dfsan_union(0, size_label, (bveq << 8) | ICmp, 64, 0, size); __taint_trace_cond(os, 0, UndefinedCheck, ub_integer_overflow); } } SANITIZER_INTERFACE_ATTRIBUTE void * __dfsw_realloc(void *ptr, size_t new_size, dfsan_label ptr_label, dfsan_label new_size_label, dfsan_label *ret_label) { __taint_check_malloc_size(new_size, new_size_label); void *ret = malloc(new_size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * new_size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, new_size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + new_size); *ret_label = bound; } } if (ptr) { if (ret) { // copy old labels size_t size = malloc_usable_size(ptr); size = size < new_size ? size : new_size; internal_memcpy(ret, ptr, size); internal_memcpy(shadow_for(ret), shadow_for(ptr), sizeof(dfsan_label) * size); } if (flags().trace_bounds) { // mark old buffer as freed without truely free it dfsan_label_info *info = dfsan_get_label_info(ptr_label); if (info->op != Alloca) { AOUT("WARNING: wrong ptr op %d = %d\n", ptr_label, info->op); // Die(); } else info->op = Free; } else { free(ptr); } } if (flags().trace_bounds) { AOUT("old ptr: %p = %d, new size: %lu = %d, new ptr: %p = %d\n", ptr, ptr_label, new_size, new_size_label, ret, *ret_label); } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void * __dfsw___libc_realloc(void *ptr, size_t new_size, dfsan_label ptr_label, dfsan_label new_size_label, dfsan_label *ret_label) { __taint_check_malloc_size(new_size, new_size_label); void *ret = malloc(new_size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * new_size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, new_size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + new_size); *ret_label = bound; } } if (ptr) { if (ret) { // copy old labels size_t size = malloc_usable_size(ptr); size = size < new_size ? size : new_size; internal_memcpy(ret, ptr, size); internal_memcpy(shadow_for(ret), shadow_for(ptr), sizeof(dfsan_label) * size); } if (flags().trace_bounds) { // mark old buffer as freed without truely free it dfsan_label_info *info = dfsan_get_label_info(ptr_label); if (info->op != Alloca) { AOUT("WARNING: wrong ptr op %d = %d\n", ptr_label, info->op); // Die(); } else info->op = Free; } else { free(ptr); } } if (flags().trace_bounds) { AOUT("old ptr: %p = %d, new size: %lu = %d, new ptr: %p = %d\n", ptr, ptr_label, new_size, new_size_label, ret, *ret_label); } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_reallocarray(void *ptr, size_t nmemb, size_t new_size, dfsan_label ptr_label, dfsan_label nmemb_label, dfsan_label new_size_label, dfsan_label *ret_label) { if (nmemb_label != 0 || new_size_label != 0) { dfsan_label byte_size = dfsan_union(nmemb_label, new_size_label, Mul, 64, nmemb, new_size); __taint_check_malloc_size(nmemb * new_size, byte_size); } void *ret = calloc(nmemb, new_size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * new_size * nmemb); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(nmemb_label, new_size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + (new_size * nmemb)); *ret_label = bound; } } if (ptr) { if (ret) { // copy old labels size_t size = malloc_usable_size(ptr); size = size < new_size ? size : new_size * nmemb; internal_memcpy(ret, ptr, size); internal_memcpy(shadow_for(ret), shadow_for(ptr), sizeof(dfsan_label) * size); } if (flags().trace_bounds) { // mark old buffer as freed without truely free it dfsan_label_info *info = dfsan_get_label_info(ptr_label); if (info->op != Alloca) { AOUT("WARNING: wrong ptr op %d = %d\n", ptr_label, info->op); // Die(); } else info->op = Free; } else { free(ptr); } } if (flags().trace_bounds) { AOUT("old ptr: %p = %d, new size: %lu = %d, new ptr: %p = %d\n", ptr, ptr_label, new_size, new_size_label, ret, *ret_label); } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw___libc_reallocarray(void *ptr, size_t nmemb, size_t new_size, dfsan_label ptr_label, dfsan_label nmemb_label, dfsan_label new_size_label, dfsan_label *ret_label) { if (nmemb_label != 0 || new_size_label != 0) { dfsan_label byte_size = dfsan_union(nmemb_label, new_size_label, Mul, 64, nmemb, new_size); __taint_check_malloc_size(nmemb * new_size, byte_size); } void *ret = calloc(nmemb, new_size); if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * new_size * nmemb); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(nmemb_label, new_size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + (new_size * nmemb)); *ret_label = bound; } } if (ptr) { if (ret) { // copy old labels size_t size = malloc_usable_size(ptr); size = size < new_size ? size : new_size * nmemb; internal_memcpy(ret, ptr, size); internal_memcpy(shadow_for(ret), shadow_for(ptr), sizeof(dfsan_label) * size); } if (flags().trace_bounds) { // mark old buffer as freed without truely free it dfsan_label_info *info = dfsan_get_label_info(ptr_label); if (info->op != Alloca) { AOUT("WARNING: wrong ptr op %d = %d\n", ptr_label, info->op); // Die(); } else info->op = Free; } else { free(ptr); } } if (flags().trace_bounds) { AOUT("old ptr: %p = %d, nmemb: %lu = %d, new size: %lu = %d, new ptr: %p = %d\n", ptr, ptr_label, nmemb, nmemb_label, new_size, new_size_label, ret, *ret_label); } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_calloc(size_t nmemb, size_t size, dfsan_label nmemb_label, dfsan_label size_label, dfsan_label *ret_label) { if (nmemb_label != 0 || size_label != 0) { dfsan_label byte_size = dfsan_union(nmemb_label, size_label, Mul, 64, nmemb, size); __taint_check_malloc_size(nmemb * size, byte_size); } void *ret = calloc(nmemb, size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * size * nmemb); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(nmemb_label, size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + (size * nmemb)); *ret_label = bound; AOUT("nmemb: %lu = %d, size: %lu = %d, addr: %p = %d\n", nmemb, nmemb_label, size, size_label, ret, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw___libc_calloc(size_t nmemb, size_t size, dfsan_label nmemb_label, dfsan_label size_label, dfsan_label *ret_label) { if (nmemb_label != 0 || size_label != 0) { dfsan_label byte_size = dfsan_union(nmemb_label, size_label, Mul, 64, nmemb, size); __taint_check_malloc_size(nmemb * size, byte_size); } void *ret = calloc(nmemb, size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * size * nmemb); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(nmemb_label, size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + (size * nmemb)); *ret_label = bound; AOUT("nmemb: %lu = %d, size: %lu = %d, addr: %p = %d\n", nmemb, nmemb_label, size, size_label, ret, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_malloc(size_t size, dfsan_label size_label, dfsan_label *ret_label) { __taint_check_malloc_size(size, size_label); void *ret = malloc(size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + size); *ret_label = bound; AOUT("length: %lu = %d, addr: %p = %d\n", size, size_label, ret, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw___libc_malloc(size_t size, dfsan_label size_label, dfsan_label *ret_label) { __taint_check_malloc_size(size, size_label); void *ret = malloc(size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + size); *ret_label = bound; AOUT("length: %lu = %d, addr: %p = %d\n", size, size_label, ret, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_aligned_alloc(size_t alignment, size_t size, dfsan_label alignment_label, dfsan_label size_label, dfsan_label *ret_label) { __taint_check_malloc_size(size, size_label); void *ret = aligned_alloc(alignment, size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + size); *ret_label = bound; AOUT("length: %lu = %d, addr: %p = %d\n", size, size_label, ret, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_posix_memalign(void **memptr, size_t alignment, size_t size, dfsan_label memptr_label, dfsan_label alignment_label, dfsan_label size_label, dfsan_label *ret_label) { __taint_check_malloc_size(size, size_label); int ret = posix_memalign(memptr, alignment, size); *ret_label = 0; if (!ret && memptr && *memptr) { internal_memset(shadow_for(*memptr), 0, sizeof(dfsan_label) * size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, size_label, Alloca, sizeof(*memptr) * 8, (uint64_t)(*memptr), (uint64_t)(*memptr) + size); dfsan_set_label(bound, memptr, sizeof(*memptr)); AOUT("length: %lu = %d, addr: %p = %d\n", size, size_label, *memptr, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_valloc(size_t size, dfsan_label size_label, dfsan_label *ret_label) { __taint_check_malloc_size(size, size_label); void *ret = valloc(size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + size); *ret_label = bound; AOUT("length: %lu = %d, addr: %p = %d\n", size, size_label, ret, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw___libc_valloc(size_t size, dfsan_label size_label, dfsan_label *ret_label) { __taint_check_malloc_size(size, size_label); void *ret = valloc(size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + size); *ret_label = bound; AOUT("length: %lu = %d, addr: %p = %d\n", size, size_label, ret, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_memalign(size_t alignment, size_t size, dfsan_label alignment_label, dfsan_label size_label, dfsan_label *ret_label) { __taint_check_malloc_size(size, size_label); void *ret = memalign(alignment, size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + size); *ret_label = bound; AOUT("length: %lu = %d, addr: %p = %d\n", size, size_label, ret, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw___libc_memalign(size_t alignment, size_t size, dfsan_label alignment_label, dfsan_label size_label, dfsan_label *ret_label) { __taint_check_malloc_size(size, size_label); void *ret = memalign(alignment, size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + size); *ret_label = bound; AOUT("length: %lu = %d, addr: %p = %d\n", size, size_label, ret, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw_pvalloc(size_t size, dfsan_label size_label, dfsan_label *ret_label) { __taint_check_malloc_size(size, size_label); void *ret = pvalloc(size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + size); *ret_label = bound; AOUT("length: %lu = %d, addr: %p = %d\n", size, size_label, ret, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void *__dfsw___libc_pvalloc(size_t size, dfsan_label size_label, dfsan_label *ret_label) { __taint_check_malloc_size(size, size_label); void *ret = pvalloc(size); *ret_label = 0; if (ret) { internal_memset(shadow_for(ret), 0, sizeof(dfsan_label) * size); if (flags().trace_bounds) { dfsan_label bound = dfsan_union(0, size_label, Alloca, sizeof(ret) * 8, (uint64_t)ret, (uint64_t)ret + size); *ret_label = bound; AOUT("length: %lu = %d, addr: %p = %d\n", size, size_label, ret, *ret_label); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void __dfsw_free(void *ptr, dfsan_label ptr_label) { if (ptr && flags().trace_bounds) { // don't really free, a hacky way to avoid reusing the address // just mark as freed AOUT("addr: %p = %d\n", ptr, ptr_label); dfsan_label_info *info = dfsan_get_label_info(ptr_label); if (info->op == Alloca) { info->op = Free; } else if (info->op == Free) { void *addr = __builtin_return_address(0); AOUT("WARNING: double free %p = %d @%p\n", ptr, ptr_label, addr); __taint_trace_memerr(ptr_label, (uptr)ptr, 0, 0, F_MEMERR_FREE, addr); } else { AOUT("WARNING: wrong ptr op %d = %d @%p\n", ptr_label, info->op, __builtin_return_address(0)); // Die(); } } else { free(ptr); } } SANITIZER_INTERFACE_ATTRIBUTE void __dfsw___libc_free(void *ptr, dfsan_label ptr_label) { if (ptr && flags().trace_bounds) { // don't really free, a hacky way to avoid reusing the address // just mark as freed AOUT("addr: %p = %d\n", ptr, ptr_label); dfsan_label_info *info = dfsan_get_label_info(ptr_label); if (info->op == Alloca) { info->op = Free; } else if (info->op == Free) { void *addr = __builtin_return_address(0); AOUT("WARNING: double free %p = %d @%p\n", ptr, ptr_label, addr); __taint_trace_memerr(ptr_label, (uptr)ptr, 0, 0, F_MEMERR_FREE, addr); } else { AOUT("WARNING: wrong ptr op %d = %d\n", ptr_label, info->op); // Die(); } } else { free(ptr); } } static dfsan_label taint_getc(int fd, off_t offset, int ret) { if (ret != EOF && taint_get_file(fd)) { dfsan_label label = label = dfsan_union(get_label_for(fd, offset), CONST_LABEL, ZExt, 32, 0, 0); AOUT("%d label is readed by fgetc\n", label); } return 0; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_fgetc(FILE *stream, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t offset = ftell(stream); int ret = fgetc(stream); *ret_label = taint_getc(fd, offset, ret); return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_fgetc_unlocked(FILE *stream, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t offset = ftell(stream); int ret = fgetc(stream); *ret_label = taint_getc(fd, offset, ret); return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_getc(FILE *stream, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t offset = ftell(stream); int ret = getc(stream); *ret_label = taint_getc(fd, offset, ret); return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_getc_unlocked(FILE *stream, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t offset = ftell(stream); int ret = getc_unlocked(stream); *ret_label = taint_getc(fd, offset, ret); return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw__IO_getc(FILE *stream, dfsan_label stream_label, dfsan_label *ret_label) { int fd = fileno(stream); off_t offset = ftell(stream); int ret = getc(stream); *ret_label = taint_getc(fd, offset, ret); return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_getchar(dfsan_label *ret_label) { off_t offset = ftell(stdin); int ret = getchar(); *ret_label = taint_getc(0, offset, ret); return ret; } SANITIZER_INTERFACE_ATTRIBUTE size_t __dfsw_mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps, dfsan_label pwc_label, dfsan_label s_label, dfsan_label n_label, dfsan_label ps_label, dfsan_label *ret_label) { *ret_label = 0; size_t ret = mbrtowc(pwc, s, n, ps); if (ret == (size_t)-1 || ret == (size_t)-2) return ret; else if (pwc != 0) { dfsan_label multibyte = dfsan_read_label(s, ret); assert(false); dfsan_store_label(multibyte, (void *)pwc, sizeof(wchar_t)); } return ret; } SANITIZER_INTERFACE_ATTRIBUTE void* __dfsw_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset, dfsan_label start_label, dfsan_label len_label, dfsan_label prot_label, dfsan_label flags_label, dfsan_label fd_label, dfsan_label offset_label, dfsan_label *ret_label) { void *ret = mmap(start, length, prot, flags, fd, offset); if (ret != MAP_FAILED) { off_t fsize = taint_get_file(fd); if (fsize) { AOUT("mmap tainted file at addr %p, offset: %ld, length %lu \n", ret, offset, length); size_t tainted_length = (offset + length) > fsize ? (fsize - offset) : length; for (size_t i = 0; i < tainted_length; i++) dfsan_set_label(get_label_for(fd, offset + i), (char *)ret + i, 1); for (size_t i = tainted_length; i < length; i++) dfsan_set_label(-1, (char *)ret + i, 1); } else { dfsan_set_label(0, ret, length); } } *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_munmap(void *addr, size_t length, dfsan_label addr_label, dfsan_label length_label, dfsan_label *ret_label) { // clear sth AOUT("munmap, addr %p, length %lu \n", addr, length); int ret = munmap(addr, length); if (!ret) dfsan_set_label(0, addr, length); *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE off_t __dfsw_lseek(int fd, off_t offset, int whence, dfsan_label fd_label, dfsan_label offset_label, dfsan_label whence_label, dfsan_label *ret_label) { off_t ret = lseek(fd, offset, whence); if (ret != (off_t)-1) { if (taint_get_file(fd)) { taint_set_offset_label(offset_label); if (offset_label) { __taint_trace_offset(offset_label, offset, sizeof(offset) * 8); } } *ret_label = offset_label; } else *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE off64_t __dfsw_lseek64(int fd, off64_t offset, int whence, dfsan_label fd_label, dfsan_label offset_label, dfsan_label whence_label, dfsan_label *ret_label) { off64_t ret = lseek64(fd, offset, whence); if (ret != (off64_t)-1) { if (taint_get_file(fd)) { taint_set_offset_label(offset_label); if (offset_label) { __taint_trace_offset(offset_label, offset, sizeof(offset) * 8); } } *ret_label = offset_label; } else *ret_label = 0; return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_fseek(FILE *stream, long offset, int whence, dfsan_label stream_label, dfsan_label offset_label, dfsan_label whence_label, dfsan_label *ret_label) { int fd = fileno(stream); int ret = fseek(stream, offset, whence); *ret_label = 0; if (ret == 0 && taint_get_file(fd)) { taint_set_offset_label(offset_label); if (offset_label) { __taint_trace_offset(offset_label, offset, sizeof(offset) * 8); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_fseeko(FILE *stream, off_t offset, int whence, dfsan_label stream_label, dfsan_label offset_label, dfsan_label whence_label, dfsan_label *ret_label) { int fd = fileno(stream); int ret = fseeko(stream, offset, whence); *ret_label = 0; if (ret == 0 && taint_get_file(fd)) { taint_set_offset_label(offset_label); if (offset_label) { __taint_trace_offset(offset_label, offset, sizeof(offset) * 8); } } return ret; } SANITIZER_INTERFACE_ATTRIBUTE int __dfsw_fseeko64(FILE *stream, off64_t offset, int whence, dfsan_label stream_label, dfsan_label offset_label, dfsan_label whence_label, dfsan_label *ret_label) { int fd = fileno(stream); int ret = fseeko64(stream, offset, whence); *ret_label = 0; if (ret == 0 && taint_get_file(fd)) { taint_set_offset_label(offset_label); if (offset_label) { __taint_trace_offset(offset_label, offset, sizeof(offset) * 8); } } return ret; } } // extern "C" ================================================ FILE: runtime/dfsan/dfsan_flags.inc ================================================ //===-- dfsan_flags.inc -----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // DFSan runtime flags. // //===----------------------------------------------------------------------===// #ifndef DFSAN_FLAG # error "Define DFSAN_FLAG prior to including this file!" #endif // DFSAN_FLAG(Type, Name, DefaultValue, Description) // See COMMON_FLAG in sanitizer_flags.inc for more details. DFSAN_FLAG(bool, warn_unimplemented, true, "Whether to warn on unimplemented functions.") DFSAN_FLAG(bool, warn_nonzero_labels, false, "Whether to warn on unimplemented functions.") DFSAN_FLAG( bool, strict_data_dependencies, true, "Whether to propagate labels only when there is an obvious data dependency" "(e.g., when comparing strings, ignore the fact that the output of the" "comparison might be data-dependent on the content of the strings). This" "applies only to the custom functions defined in 'custom.c'.") DFSAN_FLAG(const char *, dump_labels_at_exit, "", "The path of the file where " "to dump the labels when the " "program terminates.") DFSAN_FLAG(const char *, taint_file, "", "The path of the file which " "will be tainted.") DFSAN_FLAG(const char *, taint_socket, "", "The network source which " "will be tainted.") DFSAN_FLAG(const char *, union_table, "union.txt", "union table.") DFSAN_FLAG(int, shm_fd, -1, "shared union table.") DFSAN_FLAG(int, pipe_fd, -1, "communication fd.") DFSAN_FLAG(bool, trace_bounds, false, "trace bounds info.") DFSAN_FLAG(bool, trace_fsize, false, "trace file size.") DFSAN_FLAG(bool, exit_on_memerror, true, "terminate on memory error.") DFSAN_FLAG(bool, solve_ub, false, "solve undefined behavior.") DFSAN_FLAG(bool, debug, false, "Print debug output.") DFSAN_FLAG(const char *, output_dir, ".", "The path for output file.") DFSAN_FLAG(int, instance_id, 0, "instance id for multi-instance fuzzing.") DFSAN_FLAG(int, session_id, 0, "session/round id.") DFSAN_FLAG(bool, force_stdin, false, "force tainting stdin.") DFSAN_FLAG(bool, enum_gep, false, "enable GEP index enumeration.") DFSAN_FLAG(int, string_map_capacity, 256, "initial capacity for string label maps.") ================================================ FILE: runtime/dfsan/dfsan_interceptors.cpp ================================================ //===-- dfsan_interceptors.cc ---------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of DataFlowSanitizer. // // Interceptors for standard library functions. //===----------------------------------------------------------------------===// #include #include #include "dfsan.h" #include "interception/interception.h" #include "sanitizer_common/sanitizer_common.h" using namespace __sanitizer; namespace { static bool interceptors_initialized; void ReleaseShadowMemoryPagesToOS(void *addr, SIZE_T length) { uptr beg_shadow_addr = (uptr)__dfsan::shadow_for(addr); void *end_addr = (void *)((uptr)addr + RoundUpTo(length, GetPageSizeCached())); uptr end_shadow_addr = (uptr)__dfsan::shadow_for(end_addr); ReleaseMemoryPagesToOS(beg_shadow_addr, end_shadow_addr); } } INTERCEPTOR(void *, mmap, void *addr, SIZE_T length, int prot, int flags, int fd, OFF_T offset) { void *res = nullptr; // interceptors_initialized is set to true during preinit_array, when we're // single-threaded. So we don't need to worry about accessing it atomically. if (!interceptors_initialized) res = (void *)syscall(__NR_mmap, addr, length, prot, flags, fd, offset); else res = REAL(mmap)(addr, length, prot, flags, fd, offset); if (res != (void*)-1) ReleaseShadowMemoryPagesToOS(res, length); return res; } INTERCEPTOR(void *, mmap64, void *addr, SIZE_T length, int prot, int flags, int fd, OFF64_T offset) { void *res = REAL(mmap64)(addr, length, prot, flags, fd, offset); if (res != (void*)-1) ReleaseShadowMemoryPagesToOS(res, length); return res; } INTERCEPTOR(int, munmap, void *addr, SIZE_T length) { int res = REAL(munmap)(addr, length); if (res != -1) { ReleaseShadowMemoryPagesToOS(addr, length); } return res; } namespace __dfsan { void InitializeInterceptors() { CHECK(!interceptors_initialized); INTERCEPT_FUNCTION(mmap); INTERCEPT_FUNCTION(mmap64); INTERCEPT_FUNCTION(munmap); interceptors_initialized = true; } } // namespace __dfsan ================================================ FILE: runtime/dfsan/dfsan_platform.h ================================================ //===-- dfsan_platform.h ----------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of DataFlowSanitizer. // // Platform specific information for DFSan. //===----------------------------------------------------------------------===// #ifndef DFSAN_PLATFORM_H #define DFSAN_PLATFORM_H namespace __dfsan { #if defined(__x86_64__) struct Mapping { static const uptr kShadowAddr = 0x10000; static const uptr kHashTableAddr = 0x400000000000; static const uptr kUnionTableAddr = 0x400100000000; static const uptr kAppAddr = 0x700000040000; static const uptr kAppBaseAddr = 0x700000000000; static const uptr kShadowMask = ~0x700000000000; }; #elif defined(__mips64) struct Mapping { static const uptr kShadowAddr = 0x10000; static const uptr kHashTableAddr = 0x2000000000; static const uptr kUnionTableAddr = 0x2100000000; static const uptr kAppAddr = 0xF000008000; static const uptr kAppBaseAddr = 0xF000000000; static const uptr kShadowMask = ~0xF000000000; }; #elif defined(__aarch64__) struct Mapping39 { static const uptr kShadowAddr = 0x10000; static const uptr kHashTableAddr = 0x1000000000; static const uptr kUnionTableAddr = 0x1100000000; static const uptr kAppAddr = 0x7000008000; static const uptr kAppBaseAddr = 0x7000000000; static const uptr kShadowMask = ~0x7800000000; }; struct Mapping42 { static const uptr kShadowAddr = 0x10000; static const uptr kHashTableAddr = 0x8000000000; static const uptr kUnionTableAddr = 0x8100000000; static const uptr kAppAddr = 0x3ff00008000; static const uptr kAppBaseAddr = 0x3ff00000000; static const uptr kShadowMask = ~0x3c000000000; }; struct Mapping48 { static const uptr kShadowAddr = 0x10000; static const uptr kHashTableAddr = 0x8000000000; static const uptr kUnionTableAddr = 0x8100000000; static const uptr kAppAddr = 0xffff00008000; static const uptr kAppBaseAddr = 0xffff00000000; static const uptr kShadowMask = ~0xfffff0000000; }; extern int vmaSize; # define DFSAN_RUNTIME_VMA 1 #else # error "DFSan not supported for this platform!" #endif enum MappingType { MAPPING_SHADOW_ADDR, MAPPING_UNION_TABLE_ADDR, MAPPING_APP_ADDR, MAPPING_APP_BASE_ADDR, MAPPING_SHADOW_MASK, MAPPING_HASH_TABLE_ADDR }; template uptr MappingImpl(void) { switch (Type) { case MAPPING_SHADOW_ADDR: return Mapping::kShadowAddr; case MAPPING_UNION_TABLE_ADDR: return Mapping::kUnionTableAddr; case MAPPING_APP_ADDR: return Mapping::kAppAddr; case MAPPING_APP_BASE_ADDR: return Mapping::kAppBaseAddr; case MAPPING_SHADOW_MASK: return Mapping::kShadowMask; case MAPPING_HASH_TABLE_ADDR: return Mapping::kHashTableAddr; } } template uptr MappingArchImpl(void) { #ifdef __aarch64__ switch (vmaSize) { case 39: return MappingImpl(); case 42: return MappingImpl(); case 48: return MappingImpl(); } DCHECK(0); return 0; #else return MappingImpl(); #endif } ALWAYS_INLINE uptr ShadowAddr() { return MappingArchImpl(); } ALWAYS_INLINE uptr UnionTableAddr() { return MappingArchImpl(); } ALWAYS_INLINE uptr AppAddr() { return MappingArchImpl(); } ALWAYS_INLINE uptr ShadowMask() { return MappingArchImpl(); } ALWAYS_INLINE uptr HashTableAddr() { return MappingArchImpl(); } ALWAYS_INLINE uptr AppBaseAddr() { return MappingArchImpl(); } } // namespace __dfsan #endif ================================================ FILE: runtime/dfsan/done_abilist.txt ================================================ ########## # added by user ######### fun:log10=functional fun:__ctype_toupper_loc=discard fun:isatty=discard fun:longjmp=discard fun:wait=discard fun:main=uninstrumented fun:main=discard ############################################################################### # DFSan interface functions ############################################################################### fun:dfsan_union=uninstrumented fun:dfsan_union=discard fun:dfsan_create_label=uninstrumented fun:dfsan_create_label=discard fun:dfsan_set_label=uninstrumented fun:dfsan_set_label=discard fun:dfsan_add_label=uninstrumented fun:dfsan_add_label=discard fun:dfsan_get_label=uninstrumented fun:dfsan_get_label=custom fun:dfsan_read_label=uninstrumented fun:dfsan_read_label=discard fun:dfsan_get_label_count=uninstrumented fun:dfsan_get_label_count=discard fun:dfsan_get_label_info=uninstrumented fun:dfsan_get_label_info=discard fun:dfsan_has_label=uninstrumented fun:dfsan_has_label=discard fun:dfsan_has_label_with_desc=uninstrumented fun:dfsan_has_label_with_desc=discard fun:dfsan_set_write_callback=uninstrumented fun:dfsan_set_write_callback=custom fun:dfsan_shadow_for=discard fun:dfsan_fun_init=uninstrumented fun:dfsan_fun_init=discard fun:dfsan_fun_fini=uninstrumented fun:dfsan_fun_fini=discard ############################################################################### # libunwind ############################################################################### fun:__clang_call_terminate=uninstrumented fun:__clang_call_terminate=discard fun:__unw_getcontext=uninstrumented fun:__unw_getcontext=discard fun:unw_getcontext=uninstrumented fun:unw_getcontext=discard fun:_ZN9libunwind13Registers_x866jumptoEv=uninstrumented fun:_ZN9libunwind13Registers_x866jumptoEv=discard fun:_ZN9libunwind16Registers_x86_646jumptoEv=uninstrumented fun:_ZN9libunwind16Registers_x86_646jumptoEv=discard fun:__libunwind_Registers_x86_64_jumpto=uninstrumented fun:__libunwind_Registers_x86_64_jumpto=discard ############################################################################### # glibc ############################################################################### # alloc and free fun:aligned_alloc=custom fun:calloc=custom fun:free=custom fun:malloc=custom fun:memalign=custom fun:posix_memalign=custom fun:pvalloc=custom fun:realloc=custom fun:reallocarray=custom fun:valloc=custom fun:__libc_calloc=custom fun:__libc_free=custom fun:__libc_malloc=custom fun:__libc_memalign=custom fun:__libc_pvalloc=custom fun:__libc_realloc=custom fun:__libc_reallocarray=custom fun:__libc_valloc=custom # Functions that return a value that depends on the input, but the output might # not be necessarily data-dependent on the input. fun:isalpha=functional fun:isdigit=functional fun:isprint=functional fun:isxdigit=functional fun:isalnum=functional fun:ispunct=functional fun:isspace=functional # Functions that return a value that is data-dependent on the input. fun:__isinf=functional fun:__isinff=functional fun:__signbit=functional fun:__signbitf=functional fun:__signbitl=functional fun:abs=functional fun:btowc=functional fun:exp=functional fun:exp2=functional fun:expf=functional fun:expl=functional fun:fabs=functional fun:finite=functional fun:finitef=functional fun:finitel=functional fun:floor=functional fun:fmod=functional fun:frexp=functional fun:frexpf=functional fun:frexpl=functional fun:isinf=functional fun:isinff=functional fun:isinfl=functional fun:isnan=functional fun:isnanf=functional fun:isnanl=functional fun:lrint=functional fun:lrintf=functional fun:lrintl=functional fun:llrint=functional fun:llrintf=functional fun:llrintl=functional fun:log=functional fun:log1p=functional fun:log1pf=functional fun:log1pl=functional fun:log2=functional fun:log2f=functional fun:log2l=functional fun:modf=functional fun:nextafter=functional fun:nextafterf=functional fun:nextafterl=functional fun:nexttoward=functional fun:nexttowardf=functional fun:nexttowardl=functional fun:pow=functional fun:powf=functional fun:powl=functional fun:round=functional fun:sqrt=functional fun:sqrtf=functional fun:wctob=functional fun:wctob=functional # Functions that produce an output that does not depend on the input (shadow is # zeroed automatically). fun:__assert_fail=discard fun:__cmsg_nxthdr=discard fun:__ctype_b_loc=discard fun:__cxa_atexit=discard fun:__errno_location=discard fun:__newlocale=discard fun:__sbrk=discard fun:__sigsetjmp=discard fun:__uselocale=discard fun:__wctype_l=discard fun:access=discard fun:alarm=discard fun:atexit=discard fun:bind=discard fun:chdir=discard # fun:close=discard fun:closedir=discard fun:connect=discard fun:dladdr=discard fun:dlclose=discard fun:epoll_create=discard fun:epoll_create1=discard fun:epoll_ctl=discard # fun:fclose=discard fun:feof=discard fun:ferror=discard fun:fflush=discard fun:fileno=discard # fun:fopen=discard fun:fprintf=discard fun:fputc=discard fun:fputc=discard fun:fputs=discard fun:fputs_unlocked=discard # fun:fseek=discard # fun:fseeko64=discard fun:ftell=discard fun:fwrite=discard fun:getenv=discard fun:getuid=discard fun:geteuid=discard fun:getpagesize=discard fun:getpid=discard fun:gettext=discard fun:kill=discard fun:listen=discard # fun:lseek=discard fun:mkdir=discard # fun:mmap=discard # fun:munmap=discard fun:ngettext=discard # fun:open=discard # fun:openat=discard fun:pipe=discard fun:posix_fadvise=discard # fun:posix_memalign=discard fun:prctl=discard fun:printf=discard fun:pthread_sigmask=discard fun:putc=discard fun:putchar=discard fun:puts=discard fun:rand=discard fun:random=discard fun:remove=discard fun:sched_getcpu=discard fun:sched_get_priority_max=discard fun:sched_setaffinity=discard fun:sched_yield=discard fun:sem_destroy=discard fun:sem_init=discard fun:sem_post=discard fun:sem_wait=discard fun:send=discard fun:sendmsg=discard fun:sendto=discard fun:setsockopt=discard fun:shutdown=discard fun:sleep=discard fun:socket=discard fun:strerror=discard fun:strspn=discard fun:strcspn=discard fun:symlink=discard fun:syscall=discard fun:unlink=discard fun:uselocale=discard fun:vfprintf=discard # Functions that produce output does not depend on the input (need to zero the # shadow manually). fun:_dl_get_tls_static_info=custom fun:clock_gettime=custom fun:dlopen=custom fun:epoll_wait=custom fun:fgets=custom fun:fstat=custom fun:getcwd=custom fun:get_current_dir_name=custom fun:getentropy=custom fun:gethostname=custom fun:getpeername=custom fun:getrlimit=custom fun:getrusage=custom fun:getsockname=custom fun:getsockopt=custom fun:nanosleep=custom fun:pread=custom fun:pread64=custom fun:read=custom fun:recv=custom fun:recvfrom=custom fun:recvmmsg=custom fun:recvmsg=custom fun:sigaltstack=custom fun:socketpair=custom fun:stat=custom fun:time=custom # Functions that produce an output that depend on the input (propagate the # shadow manually). fun:__strdup=custom fun:__strndup=custom fun:ctime_r=custom fun:inet_pton=custom fun:localtime_r=custom fun:memcpy=custom fun:memmove=custom fun:memset=custom fun:stpcpy=custom fun:strcat=custom fun:strcpy=custom fun:strdup=custom fun:strncat=custom fun:strncpy=custom fun:strndup=custom # transformation (fatoi) fun:strtod=custom fun:strtol=custom fun:strtoll=custom fun:strtoul=custom fun:strtoull=custom fun:atoi=custom fun:atol=custom fun:atoll=custom fun:tolower=custom fun:toupper=custom # Functions that produce an output that is computed from the input, but is not # necessarily data dependent. fun:bcmp=custom fun:memchr=custom fun:memcmp=custom fun:memrchr=custom fun:strcasecmp=custom fun:strchr=custom fun:strcmp=custom fun:strlen=custom fun:strncasecmp=custom fun:strncmp=custom fun:strpbrk=custom fun:strrchr=custom fun:strstr=custom fun:strnstr=custom # not standard Linux fun:strnstr=uninstrumented fun:memmem=custom ## from afl++ # memcmp-like fun:CRYPTO_memcmp=memcmp fun:OPENSSL_memcmp=memcmp fun:memcmp_const_time=memcmp fun:memcmpct=memcmp # strcmp-like (fstrcmp) fun:xmlStrcmp=strcmp fun:xmlStrEqual=strcmp fun:g_strcmp0=strcmp fun:curl_strequal=strcmp fun:strcsequal=strcmp fun:stricmp=strcmp fun:ap_cstr_casecmp=strcmp fun:OPENSSL_strcasecmp=strcmp fun:xmlStrcasecmp=strcmp fun:g_strcasecmp=strcmp fun:g_ascii_strcasecmp=strcmp fun:Curl_strcasecompare=strcmp fun:Curl_safe_strcasecompare=strcmp fun:cmsstrcasecmp=strcmp # strncmp-like (fstrcmp) fun:xmlStrncmp=strncmp fun:curl_strnequal=strncmp fun:strnicmp=strncmp fun:ap_cstr_casecmpn=strncmp fun:OPENSSL_strncasecmp=strncmp fun:xmlStrncasecmp=strncmp fun:g_ascii_strncasecmp=strcmp fun:Curl_strncasecompare=strncmp fun:g_strncasecmp=strncmp # fstrchr fun:xmlStrchr=strchr # fstrrchr # strstr (fstrstr) fun:g_strstr_len=strstr fun:ap_strcasestr=strstr fun:xmlStrstr=strstr fun:xmlStrcasestr=strstr # fprefixof fun:g_str_has_prefix=prefixof # fsuffixof fun:g_str_has_suffix=suffixof # fsubstr fun:xmlStrsub=substr # Functions which take action based on global state, such as running a callback # set by a separate function. fun:write=custom # Functions that take a callback (wrap the callback manually). fun:dl_iterate_phdr=custom fun:getpwuid_r=custom fun:poll=custom fun:sched_getaffinity=custom fun:select=custom fun:sigemptyset=custom fun:sigaction=custom #fun:signal=custom fun:gettimeofday=custom # sprintf-like fun:sprintf=custom fun:snprintf=custom # TODO: custom fun:asprintf=discard fun:qsort=discard ### synfuzz fun:__fxstat=custom fun:__getdelim=custom fun:__lxstat=custom fun:__xstat=custom fun:_IO_getc=custom fun:close=custom fun:fclose=custom fun:fgetc=custom fun:fgetc_unlocked=custom fun:fgets_unlocked=custom fun:fopen=custom fun:fopen64=custom fun:fread=custom fun:fread_unlocked=custom fun:freopen=custom fun:getchar=custom fun:getc=custom fun:getc_unlocked=custom fun:getdelim=custom fun:getline=custom fun:gets=custom fun:lstat=custom fun:mbrtowc=custom fun:mmap=custom fun:munmap=custom fun:mmap2=custom fun:open=custom fun:openat=custom fun:openat2=custom fun:lseek=custom fun:lseek64=custom fun:fseek=custom fun:fseeko=custom fun:fseeko64=custom fun:connect=custom # for LAVA fun:utmpxname=custom fun:getutxent=custom fun:setutxent=custom ############################################################################### # pthread ############################################################################### fun:__pthread_register_cancel=discard fun:__pthread_unregister_cancel=discard fun:pthread_attr_destroy=discard fun:pthread_attr_getaffinity_np=discard fun:pthread_attr_getdetachstate=discard fun:pthread_attr_getguardsize=discard fun:pthread_attr_getinheritsched=discard fun:pthread_attr_getschedparam=discard fun:pthread_attr_getschedpolicy=discard fun:pthread_attr_getscope=discard fun:pthread_attr_getstack=discard fun:pthread_attr_getstackaddr=discard fun:pthread_attr_getstacksize=discard fun:pthread_attr_init=discard fun:pthread_attr_setaffinity_np=discard fun:pthread_attr_setdetachstate=discard fun:pthread_attr_setguardsize=discard fun:pthread_attr_setinheritsched=discard fun:pthread_attr_setschedparam=discard fun:pthread_attr_setschedpolicy=discard fun:pthread_attr_setscope=discard fun:pthread_attr_setstack=discard fun:pthread_attr_setstackaddr=discard fun:pthread_attr_setstacksize=discard fun:pthread_equal=discard fun:pthread_getschedparam=discard fun:pthread_getspecific=discard fun:pthread_key_create=discard fun:pthread_key_delete=discard fun:pthread_mutex_destroy=discard fun:pthread_mutex_init=discard fun:pthread_mutex_lock=discard fun:pthread_mutex_trylock=discard fun:pthread_mutex_unlock=discard fun:pthread_mutexattr_destroy=discard fun:pthread_mutexattr_init=discard fun:pthread_mutexattr_settype=discard fun:pthread_rwlock_destroy=discard fun:pthread_rwlock_init=discard fun:pthread_rwlock_rdlock=discard fun:pthread_rwlock_timedrdlock=discard fun:pthread_rwlock_timedwrlock=discard fun:pthread_rwlock_tryrdlock=discard fun:pthread_rwlock_trywrlock=discard fun:pthread_rwlock_wrlock=discard fun:pthread_rwlock_unlock=discard fun:pthread_setschedparam=discard fun:pthread_setname_np=discard fun:pthread_once=discard fun:pthread_self=discard fun:pthread_setspecific=discard # Functions that take a callback (wrap the callback manually). fun:pthread_create=custom # Functions that produce output does not depend on the input (need to zero the # shadow manually). fun:pthread_join=custom ############################################################################### # libffi/libgo ############################################################################### # Functions that are written in asm or are called from asm. fun:ffi_call_unix64=uninstrumented fun:ffi_call_unix64=discard fun:ffi_closure_unix64_inner=uninstrumented fun:ffi_closure_unix64_inner=discard fun:ffi_closure_unix64=uninstrumented fun:ffi_closure_unix64=discard fun:__go_get_closure=uninstrumented fun:__go_get_closure=discard fun:__go_makefunc_can_recover=uninstrumented fun:__go_makefunc_can_recover=discard fun:__go_makefunc_returning=uninstrumented fun:__go_makefunc_returning=discard fun:reflect.MakeFuncStubGo=uninstrumented fun:reflect.MakeFuncStubGo=discard fun:reflect.makeFuncStub=uninstrumented fun:reflect.makeFuncStub=discard ############################################################################### # lib/Fuzzer ############################################################################### # Replaces __sanitizer_cov_trace_cmp with __dfsw___sanitizer_cov_trace_cmp fun:__sanitizer_cov_trace_cmp1=custom fun:__sanitizer_cov_trace_cmp1=uninstrumented fun:__sanitizer_cov_trace_cmp2=custom fun:__sanitizer_cov_trace_cmp2=uninstrumented fun:__sanitizer_cov_trace_cmp4=custom fun:__sanitizer_cov_trace_cmp4=uninstrumented fun:__sanitizer_cov_trace_cmp8=custom fun:__sanitizer_cov_trace_cmp8=uninstrumented fun:__sanitizer_cov_trace_const_cmp1=custom fun:__sanitizer_cov_trace_const_cmp1=uninstrumented fun:__sanitizer_cov_trace_const_cmp2=custom fun:__sanitizer_cov_trace_const_cmp2=uninstrumented fun:__sanitizer_cov_trace_const_cmp4=custom fun:__sanitizer_cov_trace_const_cmp4=uninstrumented fun:__sanitizer_cov_trace_const_cmp8=custom fun:__sanitizer_cov_trace_const_cmp8=uninstrumented # Similar for __sanitizer_cov_trace_switch fun:__sanitizer_cov_trace_switch=custom fun:__sanitizer_cov_trace_switch=uninstrumented # Ignores all other __sanitizer callbacks. fun:__sanitizer_cov=uninstrumented fun:__sanitizer_cov=discard fun:__sanitizer_cov_module_init=uninstrumented fun:__sanitizer_cov_module_init=discard fun:__sanitizer_cov_with_check=uninstrumented fun:__sanitizer_cov_with_check=discard fun:__sanitizer_set_death_callback=uninstrumented fun:__sanitizer_set_death_callback=discard fun:__sanitizer_update_counter_bitset_and_clear_counters=uninstrumented fun:__sanitizer_update_counter_bitset_and_clear_counters=discard fun:__sanitizer_cov_trace_pc*=uninstrumented fun:__sanitizer_cov_trace_pc*=discard fun:__sanitizer_cov_pcs_init=uninstrumented fun:__sanitizer_cov_pcs_init=discard fun:__sanitizer_get_current_allocated_bytes=uninstrumented fun:__sanitizer_get_current_allocated_bytes=discard fun:__sanitizer_get_heap_size=uninstrumented fun:__sanitizer_get_heap_size=discard fun:__sanitizer_get_free_bytes=uninstrumented fun:__sanitizer_get_free_bytes=discard fun:__sanitizer_get_unmapped_bytes=uninstrumented fun:__sanitizer_get_unmapped_bytes=discard fun:__sanitizer_get_estimated_allocated_size=uninstrumented fun:__sanitizer_get_estimated_allocated_size=discard fun:__sanitizer_get_ownership=uninstrumented fun:__sanitizer_get_ownership=discard fun:__sanitizer_get_allocated_size=uninstrumented fun:__sanitizer_get_allocated_size=discard fun:__sanitizer_print_stack_trace=uninstrumented fun:__sanitizer_print_stack_trace=discard fun:TcmallocSlab_Internal_PushBatch_FixedShift=uninstrumented fun:TcmallocSlab_Internal_PushBatch_FixedShift=discard fun:TcmallocSlab_Internal_PushBatch_FixedShift_VCPU=uninstrumented fun:TcmallocSlab_Internal_PushBatch_FixedShift_VCPU=discard fun:TcmallocSlab_Internal_PerCpuCmpxchg64=uninstrumented fun:TcmallocSlab_Internal_PerCpuCmpxchg64=discard fun:TcmallocSlab_Internal_PerCpuCmpxchg64_VCPU=uninstrumented fun:TcmallocSlab_Internal_PerCpuCmpxchg64_VCPU=discard fun:TcmallocSlab_Internal_PopBatch_FixedShift=uninstrumented fun:TcmallocSlab_Internal_PopBatch_FixedShift=discard fun:TcmallocSlab_Internal_PopBatch_FixedShift_VCPU=uninstrumented fun:TcmallocSlab_Internal_PopBatch_FixedShift_VCPU=discard # Ignores the dfsan wrappers. fun:__dfsw_*=uninstrumented fun:__dfsw_*=discard # Ignores taint wrappers. fun:__taint_*=uninstrumented fun:__taint_*=discard # Don't add extra parameters to the Fuzzer callback. fun:LLVMFuzzerTestOneInput=uninstrumented fun:__afl_manual_init=uninstrumented fun:__afl_manual_init=discard ================================================ FILE: runtime/dfsan/libc++_abilist.txt ================================================ fun:_ZNKSt10bad_typeid4whatEv=uninstrumented fun:_ZNKSt11logic_error4whatEv=uninstrumented fun:_ZNKSt12bad_any_cast4whatEv=uninstrumented fun:_ZNKSt12experimental15fundamentals_v112bad_any_cast4whatEv=uninstrumented fun:_ZNKSt13bad_exception4whatEv=uninstrumented fun:_ZNKSt13runtime_error4whatEv=uninstrumented fun:_ZNKSt16nested_exception14rethrow_nestedEv=uninstrumented fun:_ZNKSt18bad_variant_access4whatEv=uninstrumented fun:_ZNKSt19bad_optional_access4whatEv=uninstrumented fun:_ZNKSt20bad_array_new_length4whatEv=uninstrumented fun:_ZNKSt3__110__time_put8__do_putEPcRS1_PK2tmcc=uninstrumented fun:_ZNKSt3__110__time_put8__do_putEPwRS1_PK2tmcc=uninstrumented fun:_ZNKSt3__110error_code7messageEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb0EE11do_groupingEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb0EE13do_neg_formatEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb0EE13do_pos_formatEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb0EE14do_curr_symbolEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb0EE14do_frac_digitsEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb0EE16do_decimal_pointEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb0EE16do_negative_signEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb0EE16do_positive_signEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb0EE16do_thousands_sepEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb1EE11do_groupingEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb1EE13do_neg_formatEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb1EE13do_pos_formatEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb1EE14do_curr_symbolEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb1EE14do_frac_digitsEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb1EE16do_decimal_pointEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb1EE16do_negative_signEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb1EE16do_positive_signEv=uninstrumented fun:_ZNKSt3__110moneypunctIcLb1EE16do_thousands_sepEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb0EE11do_groupingEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb0EE13do_neg_formatEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb0EE13do_pos_formatEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb0EE14do_curr_symbolEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb0EE14do_frac_digitsEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb0EE16do_decimal_pointEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb0EE16do_negative_signEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb0EE16do_positive_signEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb0EE16do_thousands_sepEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb1EE11do_groupingEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb1EE13do_neg_formatEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb1EE13do_pos_formatEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb1EE14do_curr_symbolEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb1EE14do_frac_digitsEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb1EE16do_decimal_pointEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb1EE16do_negative_signEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb1EE16do_positive_signEv=uninstrumented fun:_ZNKSt3__110moneypunctIwLb1EE16do_thousands_sepEv=uninstrumented fun:_ZNKSt3__111__libcpp_db15__decrementableEPKv=uninstrumented fun:_ZNKSt3__111__libcpp_db15__find_c_from_iEPv=uninstrumented fun:_ZNKSt3__111__libcpp_db15__subscriptableEPKvl=uninstrumented fun:_ZNKSt3__111__libcpp_db17__dereferenceableEPKv=uninstrumented fun:_ZNKSt3__111__libcpp_db17__find_c_and_lockEPv=uninstrumented fun:_ZNKSt3__111__libcpp_db22__less_than_comparableEPKvS2_=uninstrumented fun:_ZNKSt3__111__libcpp_db6unlockEv=uninstrumented fun:_ZNKSt3__111__libcpp_db8__find_cEPv=uninstrumented fun:_ZNKSt3__111__libcpp_db9__addableEPKvl=uninstrumented fun:_ZNKSt3__112bad_weak_ptr4whatEv=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE12find_last_ofEPKcmm=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13find_first_ofEPKcmm=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE16find_last_not_ofEPKcmm=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE17find_first_not_ofEPKcmm=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4copyEPcmm=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEPKcmm=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4findEcm=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEPKcmm=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5rfindEcm=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEPKc=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKc=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmPKcm=uninstrumented fun:_ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7compareEmmRKS5_mm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE12find_last_ofEPKwmm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE13find_first_ofEPKwmm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE16find_last_not_ofEPKwmm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE17find_first_not_ofEPKwmm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4copyEPwmm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEPKwmm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE4findEwm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEPKwmm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5rfindEwm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEPKw=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKw=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmPKwm=uninstrumented fun:_ZNKSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7compareEmmRKS5_mm=uninstrumented fun:_ZNKSt3__112ctype_bynameIcE10do_tolowerEPcPKc=uninstrumented fun:_ZNKSt3__112ctype_bynameIcE10do_tolowerEc=uninstrumented fun:_ZNKSt3__112ctype_bynameIcE10do_toupperEPcPKc=uninstrumented fun:_ZNKSt3__112ctype_bynameIcE10do_toupperEc=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE10do_scan_isEtPKwS3_=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE10do_tolowerEPwPKw=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE10do_tolowerEw=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE10do_toupperEPwPKw=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE10do_toupperEw=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE11do_scan_notEtPKwS3_=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE5do_isEPKwS3_Pt=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE5do_isEtw=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE8do_widenEPKcS3_Pw=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE8do_widenEc=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE9do_narrowEPKwS3_cPc=uninstrumented fun:_ZNKSt3__112ctype_bynameIwE9do_narrowEwc=uninstrumented fun:_ZNKSt3__112strstreambuf6pcountEv=uninstrumented fun:_ZNKSt3__113random_device7entropyEv=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDiE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDiE11do_encodingEv=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDiE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDiE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDiE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDsE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDsE11do_encodingEv=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDsE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDsE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IDsE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IwE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IwE11do_encodingEv=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IwE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IwE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__114__codecvt_utf8IwE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__114collate_bynameIcE10do_compareEPKcS3_S3_S3_=uninstrumented fun:_ZNKSt3__114collate_bynameIcE12do_transformEPKcS3_=uninstrumented fun:_ZNKSt3__114collate_bynameIwE10do_compareEPKwS3_S3_S3_=uninstrumented fun:_ZNKSt3__114collate_bynameIwE12do_transformEPKwS3_=uninstrumented fun:_ZNKSt3__114error_category10equivalentERKNS_10error_codeEi=uninstrumented fun:_ZNKSt3__114error_category10equivalentEiRKNS_15error_conditionE=uninstrumented fun:_ZNKSt3__114error_category23default_error_conditionEi=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb0EE11do_encodingEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb0EE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb0EE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb0EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb0EE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb1EE11do_encodingEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb1EE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb1EE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb1EE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDiLb1EE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb0EE11do_encodingEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb0EE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb0EE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb0EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb0EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb0EE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb1EE11do_encodingEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb1EE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb1EE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb1EE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb1EE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IDsLb1EE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb0EE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb0EE11do_encodingEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb0EE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb0EE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb0EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb0EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb0EE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb1EE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb1EE11do_encodingEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb1EE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb1EE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb1EE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb1EE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__115__codecvt_utf16IwLb1EE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__115basic_streambufIcNS_11char_traitsIcEEE6getlocEv=uninstrumented fun:_ZNKSt3__115basic_streambufIwNS_11char_traitsIwEEE6getlocEv=uninstrumented fun:_ZNKSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE3strEv=uninstrumented fun:_ZNKSt3__115error_condition7messageEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb0EE11do_groupingEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb0EE13do_neg_formatEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb0EE13do_pos_formatEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb0EE14do_curr_symbolEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb0EE14do_frac_digitsEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb0EE16do_decimal_pointEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb0EE16do_negative_signEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb0EE16do_positive_signEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb0EE16do_thousands_sepEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb1EE11do_groupingEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb1EE13do_neg_formatEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb1EE13do_pos_formatEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb1EE14do_curr_symbolEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb1EE14do_frac_digitsEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb1EE16do_decimal_pointEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb1EE16do_negative_signEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb1EE16do_positive_signEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIcLb1EE16do_thousands_sepEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb0EE11do_groupingEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb0EE13do_neg_formatEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb0EE13do_pos_formatEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb0EE14do_curr_symbolEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb0EE14do_frac_digitsEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb0EE16do_decimal_pointEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb0EE16do_negative_signEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb0EE16do_positive_signEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb0EE16do_thousands_sepEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb1EE11do_groupingEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb1EE13do_neg_formatEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb1EE13do_pos_formatEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb1EE14do_curr_symbolEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb1EE14do_frac_digitsEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb1EE16do_decimal_pointEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb1EE16do_negative_signEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb1EE16do_positive_signEv=uninstrumented fun:_ZNKSt3__117moneypunct_bynameIwLb1EE16do_thousands_sepEv=uninstrumented fun:_ZNKSt3__118__time_get_storageIcE15__do_date_orderEv=uninstrumented fun:_ZNKSt3__118__time_get_storageIwE15__do_date_orderEv=uninstrumented fun:_ZNKSt3__119__libcpp_debug_info4whatEv=uninstrumented fun:_ZNKSt3__119__shared_weak_count13__get_deleterERKSt9type_info=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDiE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDiE11do_encodingEv=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDiE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDiE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDiE5do_inER11__mbstate_tPKcS5_RS5_PDiS7_RS7_=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDiE6do_outER11__mbstate_tPKDiS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDiE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDsE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDsE11do_encodingEv=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDsE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDsE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDsE5do_inER11__mbstate_tPKcS5_RS5_PDsS7_RS7_=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDsE6do_outER11__mbstate_tPKDsS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IDsE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IwE10do_unshiftER11__mbstate_tPcS4_RS4_=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IwE11do_encodingEv=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IwE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IwE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IwE5do_inER11__mbstate_tPKcS5_RS5_PwS7_RS7_=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IwE6do_outER11__mbstate_tPKwS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__120__codecvt_utf8_utf16IwE9do_lengthER11__mbstate_tPKcS5_m=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIcE3__XEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIcE3__cEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIcE3__rEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIcE3__xEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIcE7__am_pmEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIcE7__weeksEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIcE8__monthsEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIwE3__XEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIwE3__cEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIwE3__rEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIwE3__xEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIwE7__am_pmEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIwE7__weeksEv=uninstrumented fun:_ZNKSt3__120__time_get_c_storageIwE8__monthsEv=uninstrumented fun:_ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv=uninstrumented fun:_ZNKSt3__120__vector_base_commonILb1EE20__throw_out_of_rangeEv=uninstrumented fun:_ZNKSt3__121__basic_string_commonILb1EE20__throw_length_errorEv=uninstrumented fun:_ZNKSt3__121__basic_string_commonILb1EE20__throw_out_of_rangeEv=uninstrumented fun:_ZNKSt3__123__match_any_but_newlineIcE6__execERNS_7__stateIcEE=uninstrumented fun:_ZNKSt3__123__match_any_but_newlineIwE6__execERNS_7__stateIwEE=uninstrumented fun:_ZNKSt3__14__fs10filesystem18directory_iterator13__dereferenceEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem28recursive_directory_iterator13__dereferenceEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem28recursive_directory_iterator5depthEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem28recursive_directory_iterator7optionsEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path10__filenameEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path11__extensionEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path11__root_nameEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path13__parent_pathEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path15__relative_pathEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path15__root_path_rawEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path16__root_directoryEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path16lexically_normalEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path18lexically_relativeERKS2_=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path3endEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path5beginEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path6__stemEv=uninstrumented fun:_ZNKSt3__14__fs10filesystem4path9__compareENS_17basic_string_viewIcNS_11char_traitsIcEEEE=uninstrumented fun:_ZNKSt3__15ctypeIcE10do_tolowerEPcPKc=uninstrumented fun:_ZNKSt3__15ctypeIcE10do_tolowerEc=uninstrumented fun:_ZNKSt3__15ctypeIcE10do_toupperEPcPKc=uninstrumented fun:_ZNKSt3__15ctypeIcE10do_toupperEc=uninstrumented fun:_ZNKSt3__15ctypeIcE8do_widenEPKcS3_Pc=uninstrumented fun:_ZNKSt3__15ctypeIcE8do_widenEc=uninstrumented fun:_ZNKSt3__15ctypeIcE9do_narrowEPKcS3_cPc=uninstrumented fun:_ZNKSt3__15ctypeIcE9do_narrowEcc=uninstrumented fun:_ZNKSt3__15ctypeIwE10do_scan_isEtPKwS3_=uninstrumented fun:_ZNKSt3__15ctypeIwE10do_tolowerEPwPKw=uninstrumented fun:_ZNKSt3__15ctypeIwE10do_tolowerEw=uninstrumented fun:_ZNKSt3__15ctypeIwE10do_toupperEPwPKw=uninstrumented fun:_ZNKSt3__15ctypeIwE10do_toupperEw=uninstrumented fun:_ZNKSt3__15ctypeIwE11do_scan_notEtPKwS3_=uninstrumented fun:_ZNKSt3__15ctypeIwE5do_isEPKwS3_Pt=uninstrumented fun:_ZNKSt3__15ctypeIwE5do_isEtw=uninstrumented fun:_ZNKSt3__15ctypeIwE8do_widenEPKcS3_Pw=uninstrumented fun:_ZNKSt3__15ctypeIwE8do_widenEc=uninstrumented fun:_ZNKSt3__15ctypeIwE9do_narrowEPKwS3_cPc=uninstrumented fun:_ZNKSt3__15ctypeIwE9do_narrowEwc=uninstrumented fun:_ZNKSt3__16locale4nameEv=uninstrumented fun:_ZNKSt3__16locale9has_facetERNS0_2idE=uninstrumented fun:_ZNKSt3__16locale9use_facetERNS0_2idE=uninstrumented fun:_ZNKSt3__16localeeqERKS0_=uninstrumented fun:_ZNKSt3__17codecvtIDiDu11__mbstate_tE10do_unshiftERS1_PDuS4_RS4_=uninstrumented fun:_ZNKSt3__17codecvtIDiDu11__mbstate_tE11do_encodingEv=uninstrumented fun:_ZNKSt3__17codecvtIDiDu11__mbstate_tE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__17codecvtIDiDu11__mbstate_tE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__17codecvtIDiDu11__mbstate_tE5do_inERS1_PKDuS5_RS5_PDiS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIDiDu11__mbstate_tE6do_outERS1_PKDiS5_RS5_PDuS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIDiDu11__mbstate_tE9do_lengthERS1_PKDuS5_m=uninstrumented fun:_ZNKSt3__17codecvtIDic11__mbstate_tE10do_unshiftERS1_PcS4_RS4_=uninstrumented fun:_ZNKSt3__17codecvtIDic11__mbstate_tE11do_encodingEv=uninstrumented fun:_ZNKSt3__17codecvtIDic11__mbstate_tE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__17codecvtIDic11__mbstate_tE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__17codecvtIDic11__mbstate_tE5do_inERS1_PKcS5_RS5_PDiS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIDic11__mbstate_tE6do_outERS1_PKDiS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIDic11__mbstate_tE9do_lengthERS1_PKcS5_m=uninstrumented fun:_ZNKSt3__17codecvtIDsDu11__mbstate_tE10do_unshiftERS1_PDuS4_RS4_=uninstrumented fun:_ZNKSt3__17codecvtIDsDu11__mbstate_tE11do_encodingEv=uninstrumented fun:_ZNKSt3__17codecvtIDsDu11__mbstate_tE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__17codecvtIDsDu11__mbstate_tE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__17codecvtIDsDu11__mbstate_tE5do_inERS1_PKDuS5_RS5_PDsS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIDsDu11__mbstate_tE6do_outERS1_PKDsS5_RS5_PDuS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIDsDu11__mbstate_tE9do_lengthERS1_PKDuS5_m=uninstrumented fun:_ZNKSt3__17codecvtIDsc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_=uninstrumented fun:_ZNKSt3__17codecvtIDsc11__mbstate_tE11do_encodingEv=uninstrumented fun:_ZNKSt3__17codecvtIDsc11__mbstate_tE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__17codecvtIDsc11__mbstate_tE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__17codecvtIDsc11__mbstate_tE5do_inERS1_PKcS5_RS5_PDsS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIDsc11__mbstate_tE6do_outERS1_PKDsS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIDsc11__mbstate_tE9do_lengthERS1_PKcS5_m=uninstrumented fun:_ZNKSt3__17codecvtIcc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_=uninstrumented fun:_ZNKSt3__17codecvtIcc11__mbstate_tE11do_encodingEv=uninstrumented fun:_ZNKSt3__17codecvtIcc11__mbstate_tE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__17codecvtIcc11__mbstate_tE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__17codecvtIcc11__mbstate_tE5do_inERS1_PKcS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIcc11__mbstate_tE6do_outERS1_PKcS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIcc11__mbstate_tE9do_lengthERS1_PKcS5_m=uninstrumented fun:_ZNKSt3__17codecvtIwc11__mbstate_tE10do_unshiftERS1_PcS4_RS4_=uninstrumented fun:_ZNKSt3__17codecvtIwc11__mbstate_tE11do_encodingEv=uninstrumented fun:_ZNKSt3__17codecvtIwc11__mbstate_tE13do_max_lengthEv=uninstrumented fun:_ZNKSt3__17codecvtIwc11__mbstate_tE16do_always_noconvEv=uninstrumented fun:_ZNKSt3__17codecvtIwc11__mbstate_tE5do_inERS1_PKcS5_RS5_PwS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIwc11__mbstate_tE6do_outERS1_PKwS5_RS5_PcS7_RS7_=uninstrumented fun:_ZNKSt3__17codecvtIwc11__mbstate_tE9do_lengthERS1_PKcS5_m=uninstrumented fun:_ZNKSt3__17collateIcE10do_compareEPKcS3_S3_S3_=uninstrumented fun:_ZNKSt3__17collateIcE12do_transformEPKcS3_=uninstrumented fun:_ZNKSt3__17collateIcE7do_hashEPKcS3_=uninstrumented fun:_ZNKSt3__17collateIwE10do_compareEPKwS3_S3_S3_=uninstrumented fun:_ZNKSt3__17collateIwE12do_transformEPKwS3_=uninstrumented fun:_ZNKSt3__17collateIwE7do_hashEPKwS3_=uninstrumented fun:_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv=uninstrumented fun:_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRb=uninstrumented fun:_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRd=uninstrumented fun:_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRe=uninstrumented fun:_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRf=uninstrumented fun:_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRl=uninstrumented fun:_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRm=uninstrumented fun:_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRt=uninstrumented fun:_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRx=uninstrumented fun:_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjRy=uninstrumented fun:_ZNKSt3__17num_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_=uninstrumented fun:_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRPv=uninstrumented fun:_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRb=uninstrumented fun:_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRd=uninstrumented fun:_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRe=uninstrumented fun:_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRf=uninstrumented fun:_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRl=uninstrumented fun:_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRm=uninstrumented fun:_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRt=uninstrumented fun:_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRx=uninstrumented fun:_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjRy=uninstrumented fun:_ZNKSt3__17num_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjS8_=uninstrumented fun:_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPKv=uninstrumented fun:_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcb=uninstrumented fun:_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcd=uninstrumented fun:_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEce=uninstrumented fun:_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcl=uninstrumented fun:_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcm=uninstrumented fun:_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcx=uninstrumented fun:_ZNKSt3__17num_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcy=uninstrumented fun:_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPKv=uninstrumented fun:_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwb=uninstrumented fun:_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwd=uninstrumented fun:_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwe=uninstrumented fun:_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwl=uninstrumented fun:_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwm=uninstrumented fun:_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwx=uninstrumented fun:_ZNKSt3__17num_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwy=uninstrumented fun:_ZNKSt3__18ios_base6getlocEv=uninstrumented fun:_ZNKSt3__18messagesIcE6do_getEliiRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNKSt3__18messagesIcE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE=uninstrumented fun:_ZNKSt3__18messagesIcE8do_closeEl=uninstrumented fun:_ZNKSt3__18messagesIwE6do_getEliiRKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEE=uninstrumented fun:_ZNKSt3__18messagesIwE7do_openERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6localeE=uninstrumented fun:_ZNKSt3__18messagesIwE8do_closeEl=uninstrumented fun:_ZNKSt3__18numpunctIcE11do_groupingEv=uninstrumented fun:_ZNKSt3__18numpunctIcE11do_truenameEv=uninstrumented fun:_ZNKSt3__18numpunctIcE12do_falsenameEv=uninstrumented fun:_ZNKSt3__18numpunctIcE16do_decimal_pointEv=uninstrumented fun:_ZNKSt3__18numpunctIcE16do_thousands_sepEv=uninstrumented fun:_ZNKSt3__18numpunctIwE11do_groupingEv=uninstrumented fun:_ZNKSt3__18numpunctIwE11do_truenameEv=uninstrumented fun:_ZNKSt3__18numpunctIwE12do_falsenameEv=uninstrumented fun:_ZNKSt3__18numpunctIwE16do_decimal_pointEv=uninstrumented fun:_ZNKSt3__18numpunctIwE16do_thousands_sepEv=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE13do_date_orderEv=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKcSC_=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc=uninstrumented fun:_ZNKSt3__18time_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIcEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_hourERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE10__get_yearERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_am_pmERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_monthERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11__get_year4ERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_dateES4_S4_RNS_8ios_baseERjP2tm=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_timeES4_S4_RNS_8ios_baseERjP2tm=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE11do_get_yearES4_S4_RNS_8ios_baseERjP2tm=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_minuteERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE12__get_secondERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_12_hourERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_percentERS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13__get_weekdayERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE13do_date_orderEv=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE14do_get_weekdayES4_S4_RNS_8ios_baseERjP2tm=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE15__get_monthnameERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE16do_get_monthnameES4_S4_RNS_8ios_baseERjP2tm=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_weekdaynameERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE17__get_white_spaceERS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE18__get_day_year_numERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE3getES4_S4_RNS_8ios_baseERjP2tmPKwSC_=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_RNS_8ios_baseERjP2tmcc=uninstrumented fun:_ZNKSt3__18time_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE9__get_dayERiRS4_S4_RjRKNS_5ctypeIwEE=uninstrumented fun:_ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE3putES4_RNS_8ios_baseEcPK2tmPKcSC_=uninstrumented fun:_ZNKSt3__18time_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_RNS_8ios_baseEcPK2tmcc=uninstrumented fun:_ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE3putES4_RNS_8ios_baseEwPK2tmPKwSC_=uninstrumented fun:_ZNKSt3__18time_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_RNS_8ios_baseEwPK2tmcc=uninstrumented fun:_ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIcS3_NS_9allocatorIcEEEE=uninstrumented fun:_ZNKSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe=uninstrumented fun:_ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRNS_12basic_stringIwS3_NS_9allocatorIwEEEE=uninstrumented fun:_ZNKSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_getES4_S4_bRNS_8ios_baseERjRe=uninstrumented fun:_ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEcRKNS_12basic_stringIcS3_NS_9allocatorIcEEEE=uninstrumented fun:_ZNKSt3__19money_putIcNS_19ostreambuf_iteratorIcNS_11char_traitsIcEEEEE6do_putES4_bRNS_8ios_baseEce=uninstrumented fun:_ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwRKNS_12basic_stringIwS3_NS_9allocatorIwEEEE=uninstrumented fun:_ZNKSt3__19money_putIwNS_19ostreambuf_iteratorIwNS_11char_traitsIwEEEEE6do_putES4_bRNS_8ios_baseEwe=uninstrumented fun:_ZNKSt8bad_cast4whatEv=uninstrumented fun:_ZNKSt9bad_alloc4whatEv=uninstrumented fun:_ZNKSt9exception4whatEv=uninstrumented fun:_ZNSt10bad_typeidC1Ev=uninstrumented fun:_ZNSt10bad_typeidC2Ev=uninstrumented fun:_ZNSt10bad_typeidD0Ev=uninstrumented fun:_ZNSt10bad_typeidD1Ev=uninstrumented fun:_ZNSt10bad_typeidD2Ev=uninstrumented fun:_ZNSt11logic_errorC1EPKc=uninstrumented fun:_ZNSt11logic_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE=uninstrumented fun:_ZNSt11logic_errorC1ERKS_=uninstrumented fun:_ZNSt11logic_errorC2EPKc=uninstrumented fun:_ZNSt11logic_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE=uninstrumented fun:_ZNSt11logic_errorC2ERKS_=uninstrumented fun:_ZNSt11logic_errorD0Ev=uninstrumented fun:_ZNSt11logic_errorD1Ev=uninstrumented fun:_ZNSt11logic_errorD2Ev=uninstrumented fun:_ZNSt11logic_erroraSERKS_=uninstrumented fun:_ZNSt11range_errorD0Ev=uninstrumented fun:_ZNSt11range_errorD1Ev=uninstrumented fun:_ZNSt11range_errorD2Ev=uninstrumented fun:_ZNSt12domain_errorD0Ev=uninstrumented fun:_ZNSt12domain_errorD1Ev=uninstrumented fun:_ZNSt12domain_errorD2Ev=uninstrumented fun:_ZNSt12experimental19bad_optional_accessD0Ev=uninstrumented fun:_ZNSt12experimental19bad_optional_accessD1Ev=uninstrumented fun:_ZNSt12experimental19bad_optional_accessD2Ev=uninstrumented fun:_ZNSt12length_errorD0Ev=uninstrumented fun:_ZNSt12length_errorD1Ev=uninstrumented fun:_ZNSt12length_errorD2Ev=uninstrumented fun:_ZNSt12out_of_rangeD0Ev=uninstrumented fun:_ZNSt12out_of_rangeD1Ev=uninstrumented fun:_ZNSt12out_of_rangeD2Ev=uninstrumented fun:_ZNSt13bad_exceptionD0Ev=uninstrumented fun:_ZNSt13bad_exceptionD1Ev=uninstrumented fun:_ZNSt13bad_exceptionD2Ev=uninstrumented fun:_ZNSt13exception_ptrC1ERKS_=uninstrumented fun:_ZNSt13exception_ptrC2ERKS_=uninstrumented fun:_ZNSt13exception_ptrD1Ev=uninstrumented fun:_ZNSt13exception_ptrD2Ev=uninstrumented fun:_ZNSt13exception_ptraSERKS_=uninstrumented fun:_ZNSt13runtime_errorC1EPKc=uninstrumented fun:_ZNSt13runtime_errorC1ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE=uninstrumented fun:_ZNSt13runtime_errorC1ERKS_=uninstrumented fun:_ZNSt13runtime_errorC2EPKc=uninstrumented fun:_ZNSt13runtime_errorC2ERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE=uninstrumented fun:_ZNSt13runtime_errorC2ERKS_=uninstrumented fun:_ZNSt13runtime_errorD0Ev=uninstrumented fun:_ZNSt13runtime_errorD1Ev=uninstrumented fun:_ZNSt13runtime_errorD2Ev=uninstrumented fun:_ZNSt13runtime_erroraSERKS_=uninstrumented fun:_ZNSt14overflow_errorD0Ev=uninstrumented fun:_ZNSt14overflow_errorD1Ev=uninstrumented fun:_ZNSt14overflow_errorD2Ev=uninstrumented fun:_ZNSt15underflow_errorD0Ev=uninstrumented fun:_ZNSt15underflow_errorD1Ev=uninstrumented fun:_ZNSt15underflow_errorD2Ev=uninstrumented fun:_ZNSt16invalid_argumentD0Ev=uninstrumented fun:_ZNSt16invalid_argumentD1Ev=uninstrumented fun:_ZNSt16invalid_argumentD2Ev=uninstrumented fun:_ZNSt16nested_exceptionC1Ev=uninstrumented fun:_ZNSt16nested_exceptionC2Ev=uninstrumented fun:_ZNSt16nested_exceptionD0Ev=uninstrumented fun:_ZNSt16nested_exceptionD1Ev=uninstrumented fun:_ZNSt16nested_exceptionD2Ev=uninstrumented fun:_ZNSt19bad_optional_accessD0Ev=uninstrumented fun:_ZNSt19bad_optional_accessD1Ev=uninstrumented fun:_ZNSt19bad_optional_accessD2Ev=uninstrumented fun:_ZNSt20bad_array_new_lengthC1Ev=uninstrumented fun:_ZNSt20bad_array_new_lengthC2Ev=uninstrumented fun:_ZNSt20bad_array_new_lengthD0Ev=uninstrumented fun:_ZNSt20bad_array_new_lengthD1Ev=uninstrumented fun:_ZNSt20bad_array_new_lengthD2Ev=uninstrumented fun:_ZNSt3__110__time_getC1EPKc=uninstrumented fun:_ZNSt3__110__time_getC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__110__time_getC2EPKc=uninstrumented fun:_ZNSt3__110__time_getC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__110__time_getD1Ev=uninstrumented fun:_ZNSt3__110__time_getD2Ev=uninstrumented fun:_ZNSt3__110__time_putC1EPKc=uninstrumented fun:_ZNSt3__110__time_putC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__110__time_putC2EPKc=uninstrumented fun:_ZNSt3__110__time_putC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__110__time_putD1Ev=uninstrumented fun:_ZNSt3__110__time_putD2Ev=uninstrumented fun:_ZNSt3__110istrstreamD0Ev=uninstrumented fun:_ZNSt3__110istrstreamD1Ev=uninstrumented fun:_ZNSt3__110istrstreamD2Ev=uninstrumented fun:_ZNSt3__110ostrstreamD0Ev=uninstrumented fun:_ZNSt3__110ostrstreamD1Ev=uninstrumented fun:_ZNSt3__110ostrstreamD2Ev=uninstrumented fun:_ZNSt3__110to_wstringEd=uninstrumented fun:_ZNSt3__110to_wstringEe=uninstrumented fun:_ZNSt3__110to_wstringEf=uninstrumented fun:_ZNSt3__110to_wstringEi=uninstrumented fun:_ZNSt3__110to_wstringEj=uninstrumented fun:_ZNSt3__110to_wstringEl=uninstrumented fun:_ZNSt3__110to_wstringEm=uninstrumented fun:_ZNSt3__110to_wstringEx=uninstrumented fun:_ZNSt3__110to_wstringEy=uninstrumented fun:_ZNSt3__111__call_onceERVmPvPFvS2_E=uninstrumented fun:_ZNSt3__111__libcpp_db10__insert_cEPvPFPNS_8__c_nodeES1_S1_S3_E=uninstrumented fun:_ZNSt3__111__libcpp_db10__insert_iEPv=uninstrumented fun:_ZNSt3__111__libcpp_db11__insert_icEPvPKv=uninstrumented fun:_ZNSt3__111__libcpp_db15__iterator_copyEPvPKv=uninstrumented fun:_ZNSt3__111__libcpp_db16__invalidate_allEPv=uninstrumented fun:_ZNSt3__111__libcpp_db4swapEPvS1_=uninstrumented fun:_ZNSt3__111__libcpp_db9__erase_cEPv=uninstrumented fun:_ZNSt3__111__libcpp_db9__erase_iEPv=uninstrumented fun:_ZNSt3__111__libcpp_dbC1Ev=uninstrumented fun:_ZNSt3__111__libcpp_dbC2Ev=uninstrumented fun:_ZNSt3__111__libcpp_dbD1Ev=uninstrumented fun:_ZNSt3__111__libcpp_dbD2Ev=uninstrumented fun:_ZNSt3__111__money_getIcE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_SF_Ri=uninstrumented fun:_ZNSt3__111__money_getIwE13__gather_infoEbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_SJ_Ri=uninstrumented fun:_ZNSt3__111__money_putIcE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERcS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESF_SF_Ri=uninstrumented fun:_ZNSt3__111__money_putIcE8__formatEPcRS2_S3_jPKcS5_RKNS_5ctypeIcEEbRKNS_10money_base7patternEccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEESL_SL_i=uninstrumented fun:_ZNSt3__111__money_putIwE13__gather_infoEbbRKNS_6localeERNS_10money_base7patternERwS8_RNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERNS9_IwNSA_IwEENSC_IwEEEESJ_Ri=uninstrumented fun:_ZNSt3__111__money_putIwE8__formatEPwRS2_S3_jPKwS5_RKNS_5ctypeIwEEbRKNS_10money_base7patternEwwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNSE_IwNSF_IwEENSH_IwEEEESQ_i=uninstrumented fun:_ZNSt3__111regex_errorC1ENS_15regex_constants10error_typeE=uninstrumented fun:_ZNSt3__111regex_errorC2ENS_15regex_constants10error_typeE=uninstrumented fun:_ZNSt3__111regex_errorD0Ev=uninstrumented fun:_ZNSt3__111regex_errorD1Ev=uninstrumented fun:_ZNSt3__111regex_errorD2Ev=uninstrumented fun:_ZNSt3__111this_thread9sleep_forERKNS_6chrono8durationIxNS_5ratioILl1ELl1000000000EEEEE=uninstrumented fun:_ZNSt3__111timed_mutex4lockEv=uninstrumented fun:_ZNSt3__111timed_mutex6unlockEv=uninstrumented fun:_ZNSt3__111timed_mutex8try_lockEv=uninstrumented fun:_ZNSt3__111timed_mutexC1Ev=uninstrumented fun:_ZNSt3__111timed_mutexC2Ev=uninstrumented fun:_ZNSt3__111timed_mutexD1Ev=uninstrumented fun:_ZNSt3__111timed_mutexD2Ev=uninstrumented fun:_ZNSt3__112__do_nothingEPv=uninstrumented fun:_ZNSt3__112__get_sp_mutEPKv=uninstrumented fun:_ZNSt3__112__next_primeEm=uninstrumented fun:_ZNSt3__112__rs_defaultC1ERKS0_=uninstrumented fun:_ZNSt3__112__rs_defaultC1Ev=uninstrumented fun:_ZNSt3__112__rs_defaultC2ERKS0_=uninstrumented fun:_ZNSt3__112__rs_defaultC2Ev=uninstrumented fun:_ZNSt3__112__rs_defaultD1Ev=uninstrumented fun:_ZNSt3__112__rs_defaultD2Ev=uninstrumented fun:_ZNSt3__112__rs_defaultclEv=uninstrumented fun:_ZNSt3__112bad_weak_ptrD0Ev=uninstrumented fun:_ZNSt3__112bad_weak_ptrD1Ev=uninstrumented fun:_ZNSt3__112bad_weak_ptrD2Ev=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE21__grow_by_and_replaceEmmmmmmPKc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE2atEm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5eraseEmm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEPKcmm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6__initEmc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEPKcm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendERKS5_mm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6appendEmc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEPKcm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignERKS5_mm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6assignEmc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertENS_11__wrap_iterIPKcEEc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmPKcm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmRKS5_mm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6insertEmmc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE6resizeEmc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmPKcm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmRKS5_mm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7replaceEmmmc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE7reserveEm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__grow_byEmmmmmm=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9push_backEc=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_RKS4_=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1ERKS5_mmRKS4_=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_RKS4_=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2ERKS5_mmRKS4_=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED1Ev=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEED2Ev=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSERKS5_=uninstrumented fun:_ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEc=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE21__grow_by_and_replaceEmmmmmmPKw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE2atEm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE5eraseEmm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEPKwmm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6__initEmw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEPKwm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendERKS5_mm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6appendEmw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEPKwm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignERKS5_mm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6assignEmw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertENS_11__wrap_iterIPKwEEw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmPKwm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmRKS5_mm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6insertEmmw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE6resizeEmw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmPKwm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmRKS5_mm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7replaceEmmmw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE7reserveEm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9__grow_byEmmmmmm=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEE9push_backEw=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_RKS4_=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC1ERKS5_mmRKS4_=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_RKS4_=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEC2ERKS5_mmRKS4_=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED1Ev=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEED2Ev=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSERKS5_=uninstrumented fun:_ZNSt3__112basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEaSEw=uninstrumented fun:_ZNSt3__112ctype_bynameIcEC1EPKcm=uninstrumented fun:_ZNSt3__112ctype_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__112ctype_bynameIcEC2EPKcm=uninstrumented fun:_ZNSt3__112ctype_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__112ctype_bynameIcED0Ev=uninstrumented fun:_ZNSt3__112ctype_bynameIcED1Ev=uninstrumented fun:_ZNSt3__112ctype_bynameIcED2Ev=uninstrumented fun:_ZNSt3__112ctype_bynameIwEC1EPKcm=uninstrumented fun:_ZNSt3__112ctype_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__112ctype_bynameIwEC2EPKcm=uninstrumented fun:_ZNSt3__112ctype_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__112ctype_bynameIwED0Ev=uninstrumented fun:_ZNSt3__112ctype_bynameIwED1Ev=uninstrumented fun:_ZNSt3__112ctype_bynameIwED2Ev=uninstrumented fun:_ZNSt3__112future_errorC1ENS_10error_codeE=uninstrumented fun:_ZNSt3__112future_errorC2ENS_10error_codeE=uninstrumented fun:_ZNSt3__112future_errorD0Ev=uninstrumented fun:_ZNSt3__112future_errorD1Ev=uninstrumented fun:_ZNSt3__112future_errorD2Ev=uninstrumented fun:_ZNSt3__112strstreambuf3strEv=uninstrumented fun:_ZNSt3__112strstreambuf4swapERS0_=uninstrumented fun:_ZNSt3__112strstreambuf6__initEPclS1_=uninstrumented fun:_ZNSt3__112strstreambuf6freezeEb=uninstrumented fun:_ZNSt3__112strstreambuf7seekoffExNS_8ios_base7seekdirEj=uninstrumented fun:_ZNSt3__112strstreambuf7seekposENS_4fposI11__mbstate_tEEj=uninstrumented fun:_ZNSt3__112strstreambuf8overflowEi=uninstrumented fun:_ZNSt3__112strstreambuf9pbackfailEi=uninstrumented fun:_ZNSt3__112strstreambuf9underflowEv=uninstrumented fun:_ZNSt3__112strstreambufC1EPFPvmEPFvS1_E=uninstrumented fun:_ZNSt3__112strstreambufC1EPKal=uninstrumented fun:_ZNSt3__112strstreambufC1EPKcl=uninstrumented fun:_ZNSt3__112strstreambufC1EPKhl=uninstrumented fun:_ZNSt3__112strstreambufC1EPalS1_=uninstrumented fun:_ZNSt3__112strstreambufC1EPclS1_=uninstrumented fun:_ZNSt3__112strstreambufC1EPhlS1_=uninstrumented fun:_ZNSt3__112strstreambufC1El=uninstrumented fun:_ZNSt3__112strstreambufC2EPFPvmEPFvS1_E=uninstrumented fun:_ZNSt3__112strstreambufC2EPKal=uninstrumented fun:_ZNSt3__112strstreambufC2EPKcl=uninstrumented fun:_ZNSt3__112strstreambufC2EPKhl=uninstrumented fun:_ZNSt3__112strstreambufC2EPalS1_=uninstrumented fun:_ZNSt3__112strstreambufC2EPclS1_=uninstrumented fun:_ZNSt3__112strstreambufC2EPhlS1_=uninstrumented fun:_ZNSt3__112strstreambufC2El=uninstrumented fun:_ZNSt3__112strstreambufD0Ev=uninstrumented fun:_ZNSt3__112strstreambufD1Ev=uninstrumented fun:_ZNSt3__112strstreambufD2Ev=uninstrumented fun:_ZNSt3__112system_error6__initERKNS_10error_codeENS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__112system_errorC1ENS_10error_codeE=uninstrumented fun:_ZNSt3__112system_errorC1ENS_10error_codeEPKc=uninstrumented fun:_ZNSt3__112system_errorC1ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__112system_errorC1EiRKNS_14error_categoryE=uninstrumented fun:_ZNSt3__112system_errorC1EiRKNS_14error_categoryEPKc=uninstrumented fun:_ZNSt3__112system_errorC1EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__112system_errorC2ENS_10error_codeE=uninstrumented fun:_ZNSt3__112system_errorC2ENS_10error_codeEPKc=uninstrumented fun:_ZNSt3__112system_errorC2ENS_10error_codeERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__112system_errorC2EiRKNS_14error_categoryE=uninstrumented fun:_ZNSt3__112system_errorC2EiRKNS_14error_categoryEPKc=uninstrumented fun:_ZNSt3__112system_errorC2EiRKNS_14error_categoryERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__112system_errorD0Ev=uninstrumented fun:_ZNSt3__112system_errorD1Ev=uninstrumented fun:_ZNSt3__112system_errorD2Ev=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE11__read_modeEv=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE12__write_modeEv=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE4openEPKcj=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE4swapERS3_=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE4syncEv=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE5closeEv=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE6setbufEPcl=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE8overflowEi=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE9pbackfailEi=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEE9underflowEv=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEEC1EOS3_=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEEC1Ev=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEEC2EOS3_=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEEC2Ev=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEED0Ev=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEED1Ev=uninstrumented fun:_ZNSt3__113basic_filebufIcNS_11char_traitsIcEEED2Ev=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPcl=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEPclc=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EE=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERNS_15basic_streambufIcS2_EEc=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getERc=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE3getEv=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4peekEv=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4readEPcl=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4swapERS3_=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE4syncEv=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgENS_4fposI11__mbstate_tEE=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5seekgExNS_8ios_base7seekdirE=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5tellgEv=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE5ungetEv=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6ignoreEli=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC1ERS3_b=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE6sentryC2ERS3_b=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPcl=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7getlineEPclc=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE7putbackEc=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEE8readsomeEPcl=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEED2Ev=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_8ios_baseES5_E=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRNS_9basic_iosIcS2_EES6_E=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPFRS3_S4_E=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsEPNS_15basic_streambufIcS2_EE=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERPv=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERb=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERd=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERe=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERf=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERi=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERj=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERl=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERm=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERs=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERt=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERx=uninstrumented fun:_ZNSt3__113basic_istreamIcNS_11char_traitsIcEEErsERy=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwl=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEPwlw=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EE=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERNS_15basic_streambufIwS2_EEw=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getERw=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE3getEv=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4peekEv=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4readEPwl=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4swapERS3_=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE4syncEv=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgENS_4fposI11__mbstate_tEE=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5seekgExNS_8ios_base7seekdirE=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5tellgEv=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE5ungetEv=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6ignoreElj=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC1ERS3_b=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE6sentryC2ERS3_b=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwl=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7getlineEPwlw=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE7putbackEw=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEE8readsomeEPwl=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEED2Ev=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_8ios_baseES5_E=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRNS_9basic_iosIwS2_EES6_E=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPFRS3_S4_E=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsEPNS_15basic_streambufIwS2_EE=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERPv=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERb=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERd=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERe=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERf=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERi=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERj=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERl=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERm=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERs=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERt=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERx=uninstrumented fun:_ZNSt3__113basic_istreamIwNS_11char_traitsIwEEErsERy=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE3putEc=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE4swapERS3_=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5flushEv=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpENS_4fposI11__mbstate_tEE=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5seekpExNS_8ios_base7seekdirE=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5tellpEv=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE5writeEPKcl=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC1ERS3_=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryC2ERS3_=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD1Ev=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentryD2Ev=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEED2Ev=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_8ios_baseES5_E=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRNS_9basic_iosIcS2_EES6_E=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPFRS3_S4_E=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPKv=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEPNS_15basic_streambufIcS2_EE=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEb=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEd=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEe=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEf=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEi=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEj=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEl=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEm=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEs=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEt=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEx=uninstrumented fun:_ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsEy=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE3putEw=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE4swapERS3_=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5flushEv=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpENS_4fposI11__mbstate_tEE=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5seekpExNS_8ios_base7seekdirE=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5tellpEv=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE5writeEPKwl=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC1ERS3_=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryC2ERS3_=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD1Ev=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEE6sentryD2Ev=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC1EPNS_15basic_streambufIwS2_EE=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEEC2EPNS_15basic_streambufIwS2_EE=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEED2Ev=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_8ios_baseES5_E=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRNS_9basic_iosIwS2_EES6_E=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPFRS3_S4_E=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPKv=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEPNS_15basic_streambufIwS2_EE=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEb=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEd=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEe=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEf=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEi=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEj=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEl=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEm=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEs=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEt=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEx=uninstrumented fun:_ZNSt3__113basic_ostreamIwNS_11char_traitsIwEEElsEy=uninstrumented fun:_ZNSt3__113random_deviceC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__113random_deviceC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__113random_deviceD1Ev=uninstrumented fun:_ZNSt3__113random_deviceD2Ev=uninstrumented fun:_ZNSt3__113random_deviceclEv=uninstrumented fun:_ZNSt3__113shared_futureIvED1Ev=uninstrumented fun:_ZNSt3__113shared_futureIvED2Ev=uninstrumented fun:_ZNSt3__113shared_futureIvEaSERKS1_=uninstrumented fun:_ZNSt3__114__get_const_dbEv=uninstrumented fun:_ZNSt3__114__num_get_base10__get_baseERNS_8ios_baseE=uninstrumented fun:_ZNSt3__114__num_put_base12__format_intEPcPKcbj=uninstrumented fun:_ZNSt3__114__num_put_base14__format_floatEPcPKcj=uninstrumented fun:_ZNSt3__114__num_put_base18__identify_paddingEPcS1_RKNS_8ios_baseE=uninstrumented fun:_ZNSt3__114__shared_count12__add_sharedEv=uninstrumented fun:_ZNSt3__114__shared_count16__release_sharedEv=uninstrumented fun:_ZNSt3__114__shared_countD0Ev=uninstrumented fun:_ZNSt3__114__shared_countD1Ev=uninstrumented fun:_ZNSt3__114__shared_countD2Ev=uninstrumented fun:_ZNSt3__114basic_ifstreamIcNS_11char_traitsIcEEE4openEPKcj=uninstrumented fun:_ZNSt3__114basic_ifstreamIcNS_11char_traitsIcEEE4openERKNS_12basic_stringIcS2_NS_9allocatorIcEEEEj=uninstrumented fun:_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEE4swapERS3_=uninstrumented fun:_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC1EPNS_15basic_streambufIcS2_EE=uninstrumented fun:_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEEC2EPNS_15basic_streambufIcS2_EE=uninstrumented fun:_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev=uninstrumented fun:_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev=uninstrumented fun:_ZNSt3__114basic_iostreamIcNS_11char_traitsIcEEED2Ev=uninstrumented fun:_ZNSt3__114basic_ofstreamIcNS_11char_traitsIcEEE4openEPKcj=uninstrumented fun:_ZNSt3__114basic_ofstreamIcNS_11char_traitsIcEEE4openERKNS_12basic_stringIcS2_NS_9allocatorIcEEEEj=uninstrumented fun:_ZNSt3__114codecvt_bynameIDiDu11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIDiDu11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIDiDu11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIDic11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIDic11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIDic11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIDsDu11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIDsDu11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIDsDu11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIDsc11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIcc11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIcc11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIcc11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIwc11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIwc11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__114codecvt_bynameIwc11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__114collate_bynameIcEC1EPKcm=uninstrumented fun:_ZNSt3__114collate_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__114collate_bynameIcEC2EPKcm=uninstrumented fun:_ZNSt3__114collate_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__114collate_bynameIcED0Ev=uninstrumented fun:_ZNSt3__114collate_bynameIcED1Ev=uninstrumented fun:_ZNSt3__114collate_bynameIcED2Ev=uninstrumented fun:_ZNSt3__114collate_bynameIwEC1EPKcm=uninstrumented fun:_ZNSt3__114collate_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__114collate_bynameIwEC2EPKcm=uninstrumented fun:_ZNSt3__114collate_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__114collate_bynameIwED0Ev=uninstrumented fun:_ZNSt3__114collate_bynameIwED1Ev=uninstrumented fun:_ZNSt3__114collate_bynameIwED2Ev=uninstrumented fun:_ZNSt3__114error_categoryC2Ev=uninstrumented fun:_ZNSt3__114error_categoryD0Ev=uninstrumented fun:_ZNSt3__114error_categoryD1Ev=uninstrumented fun:_ZNSt3__114error_categoryD2Ev=uninstrumented fun:_ZNSt3__115__get_classnameEPKcb=uninstrumented fun:_ZNSt3__115__thread_struct25notify_all_at_thread_exitEPNS_18condition_variableEPNS_5mutexE=uninstrumented fun:_ZNSt3__115__thread_struct27__make_ready_at_thread_exitEPNS_17__assoc_sub_stateE=uninstrumented fun:_ZNSt3__115__thread_structC1Ev=uninstrumented fun:_ZNSt3__115__thread_structC2Ev=uninstrumented fun:_ZNSt3__115__thread_structD1Ev=uninstrumented fun:_ZNSt3__115__thread_structD2Ev=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekoffExNS_8ios_base7seekdirEj=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE10pubseekposENS_4fposI11__mbstate_tEEj=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setgEPcS4_S4_=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4setpEPcS4_=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4swapERS3_=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE4syncEv=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5gbumpEi=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5imbueERKNS_6localeE=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5pbumpEi=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetcEv=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sgetnEPcl=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputcEc=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputnEPKcl=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5uflowEv=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6sbumpcEv=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6setbufEPcl=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6snextcEv=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsgetnEPcl=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE6xsputnEPKcl=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7pubsyncEv=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekoffExNS_8ios_base7seekdirEj=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7seekposENS_4fposI11__mbstate_tEEj=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE7sungetcEv=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8in_availEv=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8overflowEi=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE8pubimbueERKNS_6localeE=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pbackfailEi=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9pubsetbufEPcl=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9showmanycEv=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9sputbackcEc=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE9underflowEv=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1ERKS3_=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC1Ev=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2ERKS3_=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEC2Ev=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED0Ev=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED1Ev=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEED2Ev=uninstrumented fun:_ZNSt3__115basic_streambufIcNS_11char_traitsIcEEEaSERKS3_=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekoffExNS_8ios_base7seekdirEj=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE10pubseekposENS_4fposI11__mbstate_tEEj=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setgEPwS4_S4_=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4setpEPwS4_=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4swapERS3_=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE4syncEv=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5gbumpEi=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5imbueERKNS_6localeE=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5pbumpEi=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetcEv=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sgetnEPwl=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputcEw=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5sputnEPKwl=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE5uflowEv=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6sbumpcEv=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6setbufEPwl=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6snextcEv=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsgetnEPwl=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE6xsputnEPKwl=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7pubsyncEv=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekoffExNS_8ios_base7seekdirEj=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7seekposENS_4fposI11__mbstate_tEEj=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE7sungetcEv=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8in_availEv=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8overflowEj=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE8pubimbueERKNS_6localeE=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pbackfailEj=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9pubsetbufEPwl=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9showmanycEv=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9sputbackcEw=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEE9underflowEv=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1ERKS3_=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC1Ev=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2ERKS3_=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEC2Ev=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED0Ev=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED1Ev=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEED2Ev=uninstrumented fun:_ZNSt3__115basic_streambufIwNS_11char_traitsIwEEEaSERKS3_=uninstrumented fun:_ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE3strERKNS_12basic_stringIcS2_S4_EE=uninstrumented fun:_ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE4swapERS5_=uninstrumented fun:_ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE7seekoffExNS_8ios_base7seekdirEj=uninstrumented fun:_ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE8overflowEi=uninstrumented fun:_ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE9pbackfailEi=uninstrumented fun:_ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE9underflowEv=uninstrumented fun:_ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEEC1EOS5_=uninstrumented fun:_ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEEC2EOS5_=uninstrumented fun:_ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEOS5_=uninstrumented fun:_ZNSt3__115future_categoryEv=uninstrumented fun:_ZNSt3__115numpunct_bynameIcE6__initEPKc=uninstrumented fun:_ZNSt3__115numpunct_bynameIcEC1EPKcm=uninstrumented fun:_ZNSt3__115numpunct_bynameIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__115numpunct_bynameIcEC2EPKcm=uninstrumented fun:_ZNSt3__115numpunct_bynameIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__115numpunct_bynameIcED0Ev=uninstrumented fun:_ZNSt3__115numpunct_bynameIcED1Ev=uninstrumented fun:_ZNSt3__115numpunct_bynameIcED2Ev=uninstrumented fun:_ZNSt3__115numpunct_bynameIwE6__initEPKc=uninstrumented fun:_ZNSt3__115numpunct_bynameIwEC1EPKcm=uninstrumented fun:_ZNSt3__115numpunct_bynameIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__115numpunct_bynameIwEC2EPKcm=uninstrumented fun:_ZNSt3__115numpunct_bynameIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEm=uninstrumented fun:_ZNSt3__115numpunct_bynameIwED0Ev=uninstrumented fun:_ZNSt3__115numpunct_bynameIwED1Ev=uninstrumented fun:_ZNSt3__115numpunct_bynameIwED2Ev=uninstrumented fun:_ZNSt3__115recursive_mutex4lockEv=uninstrumented fun:_ZNSt3__115recursive_mutex6unlockEv=uninstrumented fun:_ZNSt3__115recursive_mutex8try_lockEv=uninstrumented fun:_ZNSt3__115recursive_mutexC1Ev=uninstrumented fun:_ZNSt3__115recursive_mutexC2Ev=uninstrumented fun:_ZNSt3__115recursive_mutexD1Ev=uninstrumented fun:_ZNSt3__115recursive_mutexD2Ev=uninstrumented fun:_ZNSt3__115system_categoryEv=uninstrumented fun:_ZNSt3__116__check_groupingERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjS8_Rj=uninstrumented fun:_ZNSt3__116__narrow_to_utf8ILm16EED0Ev=uninstrumented fun:_ZNSt3__116__narrow_to_utf8ILm16EED1Ev=uninstrumented fun:_ZNSt3__116__narrow_to_utf8ILm16EED2Ev=uninstrumented fun:_ZNSt3__116__narrow_to_utf8ILm32EED0Ev=uninstrumented fun:_ZNSt3__116__narrow_to_utf8ILm32EED1Ev=uninstrumented fun:_ZNSt3__116__narrow_to_utf8ILm32EED2Ev=uninstrumented fun:_ZNSt3__116generic_categoryEv=uninstrumented fun:_ZNSt3__117__assoc_sub_state10__sub_waitERNS_11unique_lockINS_5mutexEEE=uninstrumented fun:_ZNSt3__117__assoc_sub_state12__make_readyEv=uninstrumented fun:_ZNSt3__117__assoc_sub_state13set_exceptionESt13exception_ptr=uninstrumented fun:_ZNSt3__117__assoc_sub_state16__on_zero_sharedEv=uninstrumented fun:_ZNSt3__117__assoc_sub_state24set_value_at_thread_exitEv=uninstrumented fun:_ZNSt3__117__assoc_sub_state28set_exception_at_thread_exitESt13exception_ptr=uninstrumented fun:_ZNSt3__117__assoc_sub_state4copyEv=uninstrumented fun:_ZNSt3__117__assoc_sub_state4waitEv=uninstrumented fun:_ZNSt3__117__assoc_sub_state9__executeEv=uninstrumented fun:_ZNSt3__117__assoc_sub_state9set_valueEv=uninstrumented fun:_ZNSt3__117__widen_from_utf8ILm16EED0Ev=uninstrumented fun:_ZNSt3__117__widen_from_utf8ILm16EED1Ev=uninstrumented fun:_ZNSt3__117__widen_from_utf8ILm16EED2Ev=uninstrumented fun:_ZNSt3__117__widen_from_utf8ILm32EED0Ev=uninstrumented fun:_ZNSt3__117__widen_from_utf8ILm32EED1Ev=uninstrumented fun:_ZNSt3__117__widen_from_utf8ILm32EED2Ev=uninstrumented fun:_ZNSt3__117declare_reachableEPv=uninstrumented fun:_ZNSt3__117iostream_categoryEv=uninstrumented fun:_ZNSt3__117moneypunct_bynameIcLb0EE4initEPKc=uninstrumented fun:_ZNSt3__117moneypunct_bynameIcLb1EE4initEPKc=uninstrumented fun:_ZNSt3__117moneypunct_bynameIwLb0EE4initEPKc=uninstrumented fun:_ZNSt3__117moneypunct_bynameIwLb1EE4initEPKc=uninstrumented fun:_ZNSt3__118__time_get_storageIcE4initERKNS_5ctypeIcEE=uninstrumented fun:_ZNSt3__118__time_get_storageIcE9__analyzeEcRKNS_5ctypeIcEE=uninstrumented fun:_ZNSt3__118__time_get_storageIcEC1EPKc=uninstrumented fun:_ZNSt3__118__time_get_storageIcEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__118__time_get_storageIcEC2EPKc=uninstrumented fun:_ZNSt3__118__time_get_storageIcEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__118__time_get_storageIwE4initERKNS_5ctypeIwEE=uninstrumented fun:_ZNSt3__118__time_get_storageIwE9__analyzeEcRKNS_5ctypeIwEE=uninstrumented fun:_ZNSt3__118__time_get_storageIwEC1EPKc=uninstrumented fun:_ZNSt3__118__time_get_storageIwEC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__118__time_get_storageIwEC2EPKc=uninstrumented fun:_ZNSt3__118__time_get_storageIwEC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEOS5_=uninstrumented fun:_ZNSt3__118condition_variable10notify_allEv=uninstrumented fun:_ZNSt3__118condition_variable10notify_oneEv=uninstrumented fun:_ZNSt3__118condition_variable15__do_timed_waitERNS_11unique_lockINS_5mutexEEENS_6chrono10time_pointINS5_12system_clockENS5_8durationIxNS_5ratioILl1ELl1000000000EEEEEEE=uninstrumented fun:_ZNSt3__118condition_variable4waitERNS_11unique_lockINS_5mutexEEE=uninstrumented fun:_ZNSt3__118condition_variableD1Ev=uninstrumented fun:_ZNSt3__118condition_variableD2Ev=uninstrumented fun:_ZNSt3__118get_pointer_safetyEv=uninstrumented fun:_ZNSt3__118shared_timed_mutex11lock_sharedEv=uninstrumented fun:_ZNSt3__118shared_timed_mutex13unlock_sharedEv=uninstrumented fun:_ZNSt3__118shared_timed_mutex15try_lock_sharedEv=uninstrumented fun:_ZNSt3__118shared_timed_mutex4lockEv=uninstrumented fun:_ZNSt3__118shared_timed_mutex6unlockEv=uninstrumented fun:_ZNSt3__118shared_timed_mutex8try_lockEv=uninstrumented fun:_ZNSt3__118shared_timed_mutexC1Ev=uninstrumented fun:_ZNSt3__118shared_timed_mutexC2Ev=uninstrumented fun:_ZNSt3__119__shared_mutex_base11lock_sharedEv=uninstrumented fun:_ZNSt3__119__shared_mutex_base13unlock_sharedEv=uninstrumented fun:_ZNSt3__119__shared_mutex_base15try_lock_sharedEv=uninstrumented fun:_ZNSt3__119__shared_mutex_base4lockEv=uninstrumented fun:_ZNSt3__119__shared_mutex_base6unlockEv=uninstrumented fun:_ZNSt3__119__shared_mutex_base8try_lockEv=uninstrumented fun:_ZNSt3__119__shared_mutex_baseC1Ev=uninstrumented fun:_ZNSt3__119__shared_mutex_baseC2Ev=uninstrumented fun:_ZNSt3__119__shared_weak_count10__add_weakEv=uninstrumented fun:_ZNSt3__119__shared_weak_count12__add_sharedEv=uninstrumented fun:_ZNSt3__119__shared_weak_count14__release_weakEv=uninstrumented fun:_ZNSt3__119__shared_weak_count16__release_sharedEv=uninstrumented fun:_ZNSt3__119__shared_weak_count4lockEv=uninstrumented fun:_ZNSt3__119__shared_weak_countD0Ev=uninstrumented fun:_ZNSt3__119__shared_weak_countD1Ev=uninstrumented fun:_ZNSt3__119__shared_weak_countD2Ev=uninstrumented fun:_ZNSt3__119__thread_local_dataEv=uninstrumented fun:_ZNSt3__119basic_istringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEOS5_=uninstrumented fun:_ZNSt3__119basic_ostringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEaSEOS5_=uninstrumented fun:_ZNSt3__119declare_no_pointersEPcm=uninstrumented fun:_ZNSt3__120__get_collation_nameEPKc=uninstrumented fun:_ZNSt3__120__libcpp_atomic_waitEPVKNS_17__cxx_atomic_implIiNS_22__cxx_atomic_base_implIiEEEEi=uninstrumented fun:_ZNSt3__120__libcpp_atomic_waitEPVKvi=uninstrumented fun:_ZNSt3__120__throw_system_errorEiPKc=uninstrumented fun:_ZNSt3__121__throw_runtime_errorEPKc=uninstrumented fun:_ZNSt3__121__undeclare_reachableEPv=uninstrumented fun:_ZNSt3__121recursive_timed_mutex4lockEv=uninstrumented fun:_ZNSt3__121recursive_timed_mutex6unlockEv=uninstrumented fun:_ZNSt3__121recursive_timed_mutex8try_lockEv=uninstrumented fun:_ZNSt3__121recursive_timed_mutexC1Ev=uninstrumented fun:_ZNSt3__121recursive_timed_mutexC2Ev=uninstrumented fun:_ZNSt3__121recursive_timed_mutexD1Ev=uninstrumented fun:_ZNSt3__121recursive_timed_mutexD2Ev=uninstrumented fun:_ZNSt3__121undeclare_no_pointersEPcm=uninstrumented fun:_ZNSt3__123__cxx_atomic_notify_allEPVKNS_17__cxx_atomic_implIiNS_22__cxx_atomic_base_implIiEEEE=uninstrumented fun:_ZNSt3__123__cxx_atomic_notify_allEPVKv=uninstrumented fun:_ZNSt3__123__cxx_atomic_notify_oneEPVKNS_17__cxx_atomic_implIiNS_22__cxx_atomic_base_implIiEEEE=uninstrumented fun:_ZNSt3__123__cxx_atomic_notify_oneEPVKv=uninstrumented fun:_ZNSt3__123__libcpp_atomic_monitorEPVKNS_17__cxx_atomic_implIiNS_22__cxx_atomic_base_implIiEEEE=uninstrumented fun:_ZNSt3__123__libcpp_atomic_monitorEPVKv=uninstrumented fun:_ZNSt3__125notify_all_at_thread_exitERNS_18condition_variableENS_11unique_lockINS_5mutexEEE=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIaaEEPaEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIccEEPcEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIddEEPdEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIeeEEPeEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIffEEPfEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIhhEEPhEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIiiEEPiEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIjjEEPjEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIllEEPlEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessImmEEPmEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIssEEPsEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIttEEPtEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIwwEEPwEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIxxEEPxEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__insertion_sort_incompleteIRNS_6__lessIyyEEPyEEbT0_S5_T_=uninstrumented fun:_ZNSt3__127__libcpp_set_debug_functionEPFvRKNS_19__libcpp_debug_infoEE=uninstrumented fun:_ZNSt3__129__libcpp_abort_debug_functionERKNS_19__libcpp_debug_infoE=uninstrumented fun:_ZNSt3__131__arrive_barrier_algorithm_baseEPNS_24__barrier_algorithm_baseEh=uninstrumented fun:_ZNSt3__132__destroy_barrier_algorithm_baseEPNS_24__barrier_algorithm_baseE=uninstrumented fun:_ZNSt3__134__construct_barrier_algorithm_baseERl=uninstrumented fun:_ZNSt3__14__fs10filesystem10__absoluteERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem10hash_valueERKNS1_4pathE=uninstrumented fun:_ZNSt3__14__fs10filesystem11__canonicalERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem11__copy_fileERKNS1_4pathES4_NS1_12copy_optionsEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem11__file_sizeERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem12__equivalentERKNS1_4pathES4_PNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem12__remove_allERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem13__fs_is_emptyERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem13__permissionsERKNS1_4pathENS1_5permsENS1_12perm_optionsEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem13__resize_fileERKNS1_4pathEmPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem14__copy_symlinkERKNS1_4pathES4_PNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem14__current_pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem14__current_pathERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem14__read_symlinkERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem15directory_entry12__do_refreshEv=uninstrumented fun:_ZNSt3__14__fs10filesystem16_FilesystemClock3nowEv=uninstrumented fun:_ZNSt3__14__fs10filesystem16__create_symlinkERKNS1_4pathES4_PNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem16__symlink_statusERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem16filesystem_error13__create_whatEi=uninstrumented fun:_ZNSt3__14__fs10filesystem16filesystem_errorD0Ev=uninstrumented fun:_ZNSt3__14__fs10filesystem16filesystem_errorD1Ev=uninstrumented fun:_ZNSt3__14__fs10filesystem16filesystem_errorD2Ev=uninstrumented fun:_ZNSt3__14__fs10filesystem17__hard_link_countERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem17__last_write_timeERKNS1_4pathENS_6chrono10time_pointINS1_16_FilesystemClockENS5_8durationInNS_5ratioILl1ELl1000000000EEEEEEEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem17__last_write_timeERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem18__create_directoryERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem18__create_directoryERKNS1_4pathES4_PNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem18__create_hard_linkERKNS1_4pathES4_PNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem18__weakly_canonicalERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem18directory_iterator11__incrementEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem18directory_iteratorC1ERKNS1_4pathEPNS_10error_codeENS1_17directory_optionsE=uninstrumented fun:_ZNSt3__14__fs10filesystem18directory_iteratorC2ERKNS1_4pathEPNS_10error_codeENS1_17directory_optionsE=uninstrumented fun:_ZNSt3__14__fs10filesystem20__create_directoriesERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem21__temp_directory_pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem26__create_directory_symlinkERKNS1_4pathES4_PNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem28recursive_directory_iterator11__incrementEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem28recursive_directory_iterator15__try_recursionEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem28recursive_directory_iterator5__popEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem28recursive_directory_iterator9__advanceEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem28recursive_directory_iteratorC1ERKNS1_4pathENS1_17directory_optionsEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem28recursive_directory_iteratorC2ERKNS1_4pathENS1_17directory_optionsEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem4path17replace_extensionERKS2_=uninstrumented fun:_ZNSt3__14__fs10filesystem4path8iterator11__decrementEv=uninstrumented fun:_ZNSt3__14__fs10filesystem4path8iterator11__incrementEv=uninstrumented fun:_ZNSt3__14__fs10filesystem6__copyERKNS1_4pathES4_NS1_12copy_optionsEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem7__spaceERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem8__removeERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem8__renameERKNS1_4pathES4_PNS_10error_codeE=uninstrumented fun:_ZNSt3__14__fs10filesystem8__statusERKNS1_4pathEPNS_10error_codeE=uninstrumented fun:_ZNSt3__14stodERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm=uninstrumented fun:_ZNSt3__14stodERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm=uninstrumented fun:_ZNSt3__14stofERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm=uninstrumented fun:_ZNSt3__14stofERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm=uninstrumented fun:_ZNSt3__14stoiERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi=uninstrumented fun:_ZNSt3__14stoiERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi=uninstrumented fun:_ZNSt3__14stolERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi=uninstrumented fun:_ZNSt3__14stolERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi=uninstrumented fun:_ZNSt3__15alignEmmRPvRm=uninstrumented fun:_ZNSt3__15ctypeIcE13classic_tableEv=uninstrumented fun:_ZNSt3__15ctypeIcE21__classic_lower_tableEv=uninstrumented fun:_ZNSt3__15ctypeIcE21__classic_upper_tableEv=uninstrumented fun:_ZNSt3__15ctypeIcEC1EPKtbm=uninstrumented fun:_ZNSt3__15ctypeIcEC2EPKtbm=uninstrumented fun:_ZNSt3__15ctypeIcED0Ev=uninstrumented fun:_ZNSt3__15ctypeIcED1Ev=uninstrumented fun:_ZNSt3__15ctypeIcED2Ev=uninstrumented fun:_ZNSt3__15ctypeIwED0Ev=uninstrumented fun:_ZNSt3__15ctypeIwED1Ev=uninstrumented fun:_ZNSt3__15ctypeIwED2Ev=uninstrumented fun:_ZNSt3__15mutex4lockEv=uninstrumented fun:_ZNSt3__15mutex6unlockEv=uninstrumented fun:_ZNSt3__15mutex8try_lockEv=uninstrumented fun:_ZNSt3__15mutexD1Ev=uninstrumented fun:_ZNSt3__15mutexD2Ev=uninstrumented fun:_ZNSt3__15stoldERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPm=uninstrumented fun:_ZNSt3__15stoldERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPm=uninstrumented fun:_ZNSt3__15stollERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi=uninstrumented fun:_ZNSt3__15stollERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi=uninstrumented fun:_ZNSt3__15stoulERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi=uninstrumented fun:_ZNSt3__15stoulERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi=uninstrumented fun:_ZNSt3__16__clocEv=uninstrumented fun:_ZNSt3__16__itoa8__u32toaEjPc=uninstrumented fun:_ZNSt3__16__itoa8__u64toaEmPc=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIaaEEPaEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIccEEPcEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIddEEPdEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIeeEEPeEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIffEEPfEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIhhEEPhEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIiiEEPiEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIjjEEPjEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIllEEPlEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessImmEEPmEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIssEEPsEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIttEEPtEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIwwEEPwEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIxxEEPxEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16__sortIRNS_6__lessIyyEEPyEEvT0_S5_T_=uninstrumented fun:_ZNSt3__16chrono12steady_clock3nowEv=uninstrumented fun:_ZNSt3__16chrono12system_clock11from_time_tEl=uninstrumented fun:_ZNSt3__16chrono12system_clock3nowEv=uninstrumented fun:_ZNSt3__16chrono12system_clock9to_time_tERKNS0_10time_pointIS1_NS0_8durationIxNS_5ratioILl1ELl1000000EEEEEEE=uninstrumented fun:_ZNSt3__16futureIvE3getEv=uninstrumented fun:_ZNSt3__16futureIvEC1EPNS_17__assoc_sub_stateE=uninstrumented fun:_ZNSt3__16futureIvEC2EPNS_17__assoc_sub_stateE=uninstrumented fun:_ZNSt3__16futureIvED1Ev=uninstrumented fun:_ZNSt3__16futureIvED2Ev=uninstrumented fun:_ZNSt3__16gslice6__initEm=uninstrumented fun:_ZNSt3__16locale14__install_ctorERKS0_PNS0_5facetEl=uninstrumented fun:_ZNSt3__16locale2id5__getEv=uninstrumented fun:_ZNSt3__16locale2id6__initEv=uninstrumented fun:_ZNSt3__16locale5facet16__on_zero_sharedEv=uninstrumented fun:_ZNSt3__16locale5facetD0Ev=uninstrumented fun:_ZNSt3__16locale5facetD1Ev=uninstrumented fun:_ZNSt3__16locale5facetD2Ev=uninstrumented fun:_ZNSt3__16locale6globalERKS0_=uninstrumented fun:_ZNSt3__16locale7classicEv=uninstrumented fun:_ZNSt3__16locale8__globalEv=uninstrumented fun:_ZNSt3__16localeC1EPKc=uninstrumented fun:_ZNSt3__16localeC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__16localeC1ERKS0_=uninstrumented fun:_ZNSt3__16localeC1ERKS0_PKci=uninstrumented fun:_ZNSt3__16localeC1ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi=uninstrumented fun:_ZNSt3__16localeC1ERKS0_S2_i=uninstrumented fun:_ZNSt3__16localeC1Ev=uninstrumented fun:_ZNSt3__16localeC2EPKc=uninstrumented fun:_ZNSt3__16localeC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE=uninstrumented fun:_ZNSt3__16localeC2ERKS0_=uninstrumented fun:_ZNSt3__16localeC2ERKS0_PKci=uninstrumented fun:_ZNSt3__16localeC2ERKS0_RKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEi=uninstrumented fun:_ZNSt3__16localeC2ERKS0_S2_i=uninstrumented fun:_ZNSt3__16localeC2Ev=uninstrumented fun:_ZNSt3__16localeD1Ev=uninstrumented fun:_ZNSt3__16localeD2Ev=uninstrumented fun:_ZNSt3__16localeaSERKS0_=uninstrumented fun:_ZNSt3__16stoullERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPmi=uninstrumented fun:_ZNSt3__16stoullERKNS_12basic_stringIwNS_11char_traitsIwEENS_9allocatorIwEEEEPmi=uninstrumented fun:_ZNSt3__16thread20hardware_concurrencyEv=uninstrumented fun:_ZNSt3__16thread4joinEv=uninstrumented fun:_ZNSt3__16thread6detachEv=uninstrumented fun:_ZNSt3__16threadD1Ev=uninstrumented fun:_ZNSt3__16threadD2Ev=uninstrumented fun:_ZNSt3__17__sort5IRNS_6__lessIeeEEPeEEjT0_S5_S5_S5_S5_T_=uninstrumented fun:_ZNSt3__17codecvtIDiDu11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__17codecvtIDiDu11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__17codecvtIDiDu11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__17codecvtIDic11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__17codecvtIDic11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__17codecvtIDic11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__17codecvtIDsDu11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__17codecvtIDsDu11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__17codecvtIDsDu11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__17codecvtIDsc11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__17codecvtIDsc11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__17codecvtIDsc11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__17codecvtIcc11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__17codecvtIcc11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__17codecvtIcc11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__17codecvtIwc11__mbstate_tEC1EPKcm=uninstrumented fun:_ZNSt3__17codecvtIwc11__mbstate_tEC1Em=uninstrumented fun:_ZNSt3__17codecvtIwc11__mbstate_tEC2EPKcm=uninstrumented fun:_ZNSt3__17codecvtIwc11__mbstate_tEC2Em=uninstrumented fun:_ZNSt3__17codecvtIwc11__mbstate_tED0Ev=uninstrumented fun:_ZNSt3__17codecvtIwc11__mbstate_tED1Ev=uninstrumented fun:_ZNSt3__17codecvtIwc11__mbstate_tED2Ev=uninstrumented fun:_ZNSt3__17collateIcED0Ev=uninstrumented fun:_ZNSt3__17collateIcED1Ev=uninstrumented fun:_ZNSt3__17collateIcED2Ev=uninstrumented fun:_ZNSt3__17collateIwED0Ev=uninstrumented fun:_ZNSt3__17collateIwED1Ev=uninstrumented fun:_ZNSt3__17collateIwED2Ev=uninstrumented fun:_ZNSt3__17promiseIvE10get_futureEv=uninstrumented fun:_ZNSt3__17promiseIvE13set_exceptionESt13exception_ptr=uninstrumented fun:_ZNSt3__17promiseIvE24set_value_at_thread_exitEv=uninstrumented fun:_ZNSt3__17promiseIvE28set_exception_at_thread_exitESt13exception_ptr=uninstrumented fun:_ZNSt3__17promiseIvE9set_valueEv=uninstrumented fun:_ZNSt3__17promiseIvEC1Ev=uninstrumented fun:_ZNSt3__17promiseIvEC2Ev=uninstrumented fun:_ZNSt3__17promiseIvED1Ev=uninstrumented fun:_ZNSt3__17promiseIvED2Ev=uninstrumented fun:_ZNSt3__18__c_node5__addEPNS_8__i_nodeE=uninstrumented fun:_ZNSt3__18__c_nodeD0Ev=uninstrumented fun:_ZNSt3__18__c_nodeD1Ev=uninstrumented fun:_ZNSt3__18__c_nodeD2Ev=uninstrumented fun:_ZNSt3__18__get_dbEv=uninstrumented fun:_ZNSt3__18__i_nodeD1Ev=uninstrumented fun:_ZNSt3__18__i_nodeD2Ev=uninstrumented fun:_ZNSt3__18__rs_getEv=uninstrumented fun:_ZNSt3__18__sp_mut4lockEv=uninstrumented fun:_ZNSt3__18__sp_mut6unlockEv=uninstrumented fun:_ZNSt3__18ios_base15sync_with_stdioEb=uninstrumented fun:_ZNSt3__18ios_base16__call_callbacksENS0_5eventE=uninstrumented fun:_ZNSt3__18ios_base17register_callbackEPFvNS0_5eventERS0_iEi=uninstrumented fun:_ZNSt3__18ios_base33__set_badbit_and_consider_rethrowEv=uninstrumented fun:_ZNSt3__18ios_base34__set_failbit_and_consider_rethrowEv=uninstrumented fun:_ZNSt3__18ios_base4InitC1Ev=uninstrumented fun:_ZNSt3__18ios_base4InitC2Ev=uninstrumented fun:_ZNSt3__18ios_base4InitD1Ev=uninstrumented fun:_ZNSt3__18ios_base4InitD2Ev=uninstrumented fun:_ZNSt3__18ios_base4initEPv=uninstrumented fun:_ZNSt3__18ios_base4moveERS0_=uninstrumented fun:_ZNSt3__18ios_base4swapERS0_=uninstrumented fun:_ZNSt3__18ios_base5clearEj=uninstrumented fun:_ZNSt3__18ios_base5imbueERKNS_6localeE=uninstrumented fun:_ZNSt3__18ios_base5iwordEi=uninstrumented fun:_ZNSt3__18ios_base5pwordEi=uninstrumented fun:_ZNSt3__18ios_base6xallocEv=uninstrumented fun:_ZNSt3__18ios_base7copyfmtERKS0_=uninstrumented fun:_ZNSt3__18ios_base7failureC1EPKcRKNS_10error_codeE=uninstrumented fun:_ZNSt3__18ios_base7failureC1ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE=uninstrumented fun:_ZNSt3__18ios_base7failureC2EPKcRKNS_10error_codeE=uninstrumented fun:_ZNSt3__18ios_base7failureC2ERKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_10error_codeE=uninstrumented fun:_ZNSt3__18ios_base7failureD0Ev=uninstrumented fun:_ZNSt3__18ios_base7failureD1Ev=uninstrumented fun:_ZNSt3__18ios_base7failureD2Ev=uninstrumented fun:_ZNSt3__18ios_baseD0Ev=uninstrumented fun:_ZNSt3__18ios_baseD1Ev=uninstrumented fun:_ZNSt3__18ios_baseD2Ev=uninstrumented fun:_ZNSt3__18numpunctIcEC1Em=uninstrumented fun:_ZNSt3__18numpunctIcEC2Em=uninstrumented fun:_ZNSt3__18numpunctIcED0Ev=uninstrumented fun:_ZNSt3__18numpunctIcED1Ev=uninstrumented fun:_ZNSt3__18numpunctIcED2Ev=uninstrumented fun:_ZNSt3__18numpunctIwEC1Em=uninstrumented fun:_ZNSt3__18numpunctIwEC2Em=uninstrumented fun:_ZNSt3__18numpunctIwED0Ev=uninstrumented fun:_ZNSt3__18numpunctIwED1Ev=uninstrumented fun:_ZNSt3__18numpunctIwED2Ev=uninstrumented fun:_ZNSt3__18valarrayImE6resizeEmm=uninstrumented fun:_ZNSt3__18valarrayImEC1Em=uninstrumented fun:_ZNSt3__18valarrayImEC2Em=uninstrumented fun:_ZNSt3__18valarrayImED1Ev=uninstrumented fun:_ZNSt3__18valarrayImED2Ev=uninstrumented fun:_ZNSt3__19__num_getIcE17__stage2_int_loopEciPcRS2_RjcRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_S2_=uninstrumented fun:_ZNSt3__19__num_getIcE17__stage2_int_prepERNS_8ios_baseEPcRc=uninstrumented fun:_ZNSt3__19__num_getIcE19__stage2_float_loopEcRbRcPcRS4_ccRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjS4_=uninstrumented fun:_ZNSt3__19__num_getIcE19__stage2_float_prepERNS_8ios_baseEPcRcS5_=uninstrumented fun:_ZNSt3__19__num_getIwE17__stage2_int_loopEwiPcRS2_RjwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSD_Pw=uninstrumented fun:_ZNSt3__19__num_getIwE17__stage2_int_prepERNS_8ios_baseEPwRw=uninstrumented fun:_ZNSt3__19__num_getIwE19__stage2_float_loopEwRbRcPcRS4_wwRKNS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEPjRSE_RjPw=uninstrumented fun:_ZNSt3__19__num_getIwE19__stage2_float_prepERNS_8ios_baseEPwRwS5_=uninstrumented fun:_ZNSt3__19__num_putIcE21__widen_and_group_intEPcS2_S2_S2_RS2_S3_RKNS_6localeE=uninstrumented fun:_ZNSt3__19__num_putIcE23__widen_and_group_floatEPcS2_S2_S2_RS2_S3_RKNS_6localeE=uninstrumented fun:_ZNSt3__19__num_putIwE21__widen_and_group_intEPcS2_S2_PwRS3_S4_RKNS_6localeE=uninstrumented fun:_ZNSt3__19__num_putIwE23__widen_and_group_floatEPcS2_S2_PwRS3_S4_RKNS_6localeE=uninstrumented fun:_ZNSt3__19basic_iosIcNS_11char_traitsIcEEE7copyfmtERKS3_=uninstrumented fun:_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED0Ev=uninstrumented fun:_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED1Ev=uninstrumented fun:_ZNSt3__19basic_iosIcNS_11char_traitsIcEEED2Ev=uninstrumented fun:_ZNSt3__19basic_iosIwNS_11char_traitsIwEEE7copyfmtERKS3_=uninstrumented fun:_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED0Ev=uninstrumented fun:_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED1Ev=uninstrumented fun:_ZNSt3__19basic_iosIwNS_11char_traitsIwEEED2Ev=uninstrumented fun:_ZNSt3__19money_getIcNS_19istreambuf_iteratorIcNS_11char_traitsIcEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIcEERNS_10unique_ptrIcPFvPvEEERPcSM_=uninstrumented fun:_ZNSt3__19money_getIwNS_19istreambuf_iteratorIwNS_11char_traitsIwEEEEE8__do_getERS4_S4_bRKNS_6localeEjRjRbRKNS_5ctypeIwEERNS_10unique_ptrIwPFvPvEEERPwSM_=uninstrumented fun:_ZNSt3__19strstreamD0Ev=uninstrumented fun:_ZNSt3__19strstreamD1Ev=uninstrumented fun:_ZNSt3__19strstreamD2Ev=uninstrumented fun:_ZNSt3__19to_stringEd=uninstrumented fun:_ZNSt3__19to_stringEe=uninstrumented fun:_ZNSt3__19to_stringEf=uninstrumented fun:_ZNSt3__19to_stringEi=uninstrumented fun:_ZNSt3__19to_stringEj=uninstrumented fun:_ZNSt3__19to_stringEl=uninstrumented fun:_ZNSt3__19to_stringEm=uninstrumented fun:_ZNSt3__19to_stringEx=uninstrumented fun:_ZNSt3__19to_stringEy=uninstrumented fun:_ZNSt3__1plIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_12basic_stringIT_T0_T1_EEPKS6_RKS9_=uninstrumented fun:_ZNSt8bad_castC1Ev=uninstrumented fun:_ZNSt8bad_castC2Ev=uninstrumented fun:_ZNSt8bad_castD0Ev=uninstrumented fun:_ZNSt8bad_castD1Ev=uninstrumented fun:_ZNSt8bad_castD2Ev=uninstrumented fun:_ZNSt9bad_allocC1Ev=uninstrumented fun:_ZNSt9bad_allocC2Ev=uninstrumented fun:_ZNSt9bad_allocD0Ev=uninstrumented fun:_ZNSt9bad_allocD1Ev=uninstrumented fun:_ZNSt9bad_allocD2Ev=uninstrumented fun:_ZNSt9exceptionD0Ev=uninstrumented fun:_ZNSt9exceptionD1Ev=uninstrumented fun:_ZNSt9exceptionD2Ev=uninstrumented fun:_ZNSt9type_infoD0Ev=uninstrumented fun:_ZNSt9type_infoD1Ev=uninstrumented fun:_ZNSt9type_infoD2Ev=uninstrumented fun:_ZSt10unexpectedv=uninstrumented fun:_ZSt13get_terminatev=uninstrumented fun:_ZSt13set_terminatePFvvE=uninstrumented fun:_ZSt14get_unexpectedv=uninstrumented fun:_ZSt14set_unexpectedPFvvE=uninstrumented fun:_ZSt15get_new_handlerv=uninstrumented fun:_ZSt15set_new_handlerPFvvE=uninstrumented fun:_ZSt17__throw_bad_allocv=uninstrumented fun:_ZSt17current_exceptionv=uninstrumented fun:_ZSt17rethrow_exceptionSt13exception_ptr=uninstrumented fun:_ZSt18uncaught_exceptionv=uninstrumented fun:_ZSt19uncaught_exceptionsv=uninstrumented fun:_ZSt9terminatev=uninstrumented fun:_ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev=uninstrumented fun:_ZThn16_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev=uninstrumented fun:_ZThn16_NSt3__19strstreamD0Ev=uninstrumented fun:_ZThn16_NSt3__19strstreamD1Ev=uninstrumented fun:_ZTv0_n24_NSt3__110istrstreamD0Ev=uninstrumented fun:_ZTv0_n24_NSt3__110istrstreamD1Ev=uninstrumented fun:_ZTv0_n24_NSt3__110ostrstreamD0Ev=uninstrumented fun:_ZTv0_n24_NSt3__110ostrstreamD1Ev=uninstrumented fun:_ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED0Ev=uninstrumented fun:_ZTv0_n24_NSt3__113basic_istreamIcNS_11char_traitsIcEEED1Ev=uninstrumented fun:_ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED0Ev=uninstrumented fun:_ZTv0_n24_NSt3__113basic_istreamIwNS_11char_traitsIwEEED1Ev=uninstrumented fun:_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED0Ev=uninstrumented fun:_ZTv0_n24_NSt3__113basic_ostreamIcNS_11char_traitsIcEEED1Ev=uninstrumented fun:_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED0Ev=uninstrumented fun:_ZTv0_n24_NSt3__113basic_ostreamIwNS_11char_traitsIwEEED1Ev=uninstrumented fun:_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED0Ev=uninstrumented fun:_ZTv0_n24_NSt3__114basic_iostreamIcNS_11char_traitsIcEEED1Ev=uninstrumented fun:_ZTv0_n24_NSt3__19strstreamD0Ev=uninstrumented fun:_ZTv0_n24_NSt3__19strstreamD1Ev=uninstrumented fun:_ZdaPv=uninstrumented fun:_ZdaPvRKSt9nothrow_t=uninstrumented fun:_ZdaPvSt11align_val_t=uninstrumented fun:_ZdaPvSt11align_val_tRKSt9nothrow_t=uninstrumented fun:_ZdaPvm=uninstrumented fun:_ZdaPvmSt11align_val_t=uninstrumented fun:_ZdlPv=uninstrumented fun:_ZdlPvRKSt9nothrow_t=uninstrumented fun:_ZdlPvSt11align_val_t=uninstrumented fun:_ZdlPvSt11align_val_tRKSt9nothrow_t=uninstrumented fun:_ZdlPvm=uninstrumented fun:_ZdlPvmSt11align_val_t=uninstrumented fun:_Znam=uninstrumented fun:_ZnamRKSt9nothrow_t=uninstrumented fun:_ZnamSt11align_val_t=uninstrumented fun:_ZnamSt11align_val_tRKSt9nothrow_t=uninstrumented fun:_Znwm=uninstrumented fun:_ZnwmRKSt9nothrow_t=uninstrumented fun:_ZnwmSt11align_val_t=uninstrumented fun:_ZnwmSt11align_val_tRKSt9nothrow_t=uninstrumented fun:__cxa_allocate_dependent_exception=uninstrumented fun:__cxa_allocate_exception=uninstrumented fun:__cxa_bad_cast=uninstrumented fun:__cxa_bad_typeid=uninstrumented fun:__cxa_begin_catch=uninstrumented fun:__cxa_call_unexpected=uninstrumented fun:__cxa_current_exception_type=uninstrumented fun:__cxa_current_primary_exception=uninstrumented fun:__cxa_decrement_exception_refcount=uninstrumented fun:__cxa_deleted_virtual=uninstrumented fun:__cxa_demangle=uninstrumented fun:__cxa_end_catch=uninstrumented fun:__cxa_free_dependent_exception=uninstrumented fun:__cxa_free_exception=uninstrumented fun:__cxa_get_exception_ptr=uninstrumented fun:__cxa_get_globals=uninstrumented fun:__cxa_get_globals_fast=uninstrumented fun:__cxa_guard_abort=uninstrumented fun:__cxa_guard_acquire=uninstrumented fun:__cxa_guard_release=uninstrumented fun:__cxa_increment_exception_refcount=uninstrumented fun:__cxa_pure_virtual=uninstrumented fun:__cxa_rethrow=uninstrumented fun:__cxa_rethrow_primary_exception=uninstrumented fun:__cxa_thread_atexit=uninstrumented fun:__cxa_throw=uninstrumented fun:__cxa_throw_bad_array_new_length=uninstrumented fun:__cxa_uncaught_exception=uninstrumented fun:__cxa_uncaught_exceptions=uninstrumented fun:__cxa_vec_cctor=uninstrumented fun:__cxa_vec_cleanup=uninstrumented fun:__cxa_vec_ctor=uninstrumented fun:__cxa_vec_delete=uninstrumented fun:__cxa_vec_delete2=uninstrumented fun:__cxa_vec_delete3=uninstrumented fun:__cxa_vec_dtor=uninstrumented fun:__cxa_vec_new=uninstrumented fun:__cxa_vec_new2=uninstrumented fun:__cxa_vec_new3=uninstrumented fun:__divti3=uninstrumented fun:__dynamic_cast=uninstrumented fun:__gxx_personality_v0=uninstrumented fun:__udivmodti4=uninstrumented ================================================ FILE: runtime/dfsan/libc_ubuntu1404_abilist.txt ================================================ fun:_Exit=uninstrumented fun:_IO_adjust_column=uninstrumented fun:_IO_adjust_wcolumn=uninstrumented fun:_IO_default_doallocate=uninstrumented fun:_IO_default_finish=uninstrumented fun:_IO_default_pbackfail=uninstrumented fun:_IO_default_uflow=uninstrumented fun:_IO_default_xsgetn=uninstrumented fun:_IO_default_xsputn=uninstrumented fun:_IO_do_write=uninstrumented fun:_IO_doallocbuf=uninstrumented fun:_IO_fclose=uninstrumented fun:_IO_fdopen=uninstrumented fun:_IO_feof=uninstrumented fun:_IO_ferror=uninstrumented fun:_IO_fflush=uninstrumented fun:_IO_fgetpos=uninstrumented fun:_IO_fgetpos64=uninstrumented fun:_IO_fgets=uninstrumented fun:_IO_file_attach=uninstrumented fun:_IO_file_close=uninstrumented fun:_IO_file_close_it=uninstrumented fun:_IO_file_doallocate=uninstrumented fun:_IO_file_finish=uninstrumented fun:_IO_file_fopen=uninstrumented fun:_IO_file_init=uninstrumented fun:_IO_file_open=uninstrumented fun:_IO_file_overflow=uninstrumented fun:_IO_file_read=uninstrumented fun:_IO_file_seek=uninstrumented fun:_IO_file_seekoff=uninstrumented fun:_IO_file_setbuf=uninstrumented fun:_IO_file_stat=uninstrumented fun:_IO_file_sync=uninstrumented fun:_IO_file_underflow=uninstrumented fun:_IO_file_write=uninstrumented fun:_IO_file_xsputn=uninstrumented fun:_IO_flockfile=uninstrumented fun:_IO_flush_all=uninstrumented fun:_IO_flush_all_linebuffered=uninstrumented fun:_IO_fopen=uninstrumented fun:_IO_fprintf=uninstrumented fun:_IO_fputs=uninstrumented fun:_IO_fread=uninstrumented fun:_IO_free_backup_area=uninstrumented fun:_IO_free_wbackup_area=uninstrumented fun:_IO_fsetpos=uninstrumented fun:_IO_fsetpos64=uninstrumented fun:_IO_ftell=uninstrumented fun:_IO_ftrylockfile=uninstrumented fun:_IO_funlockfile=uninstrumented fun:_IO_fwrite=uninstrumented fun:_IO_getc=uninstrumented fun:_IO_getline=uninstrumented fun:_IO_getline_info=uninstrumented fun:_IO_gets=uninstrumented fun:_IO_init=uninstrumented fun:_IO_init_marker=uninstrumented fun:_IO_init_wmarker=uninstrumented fun:_IO_iter_begin=uninstrumented fun:_IO_iter_end=uninstrumented fun:_IO_iter_file=uninstrumented fun:_IO_iter_next=uninstrumented fun:_IO_least_wmarker=uninstrumented fun:_IO_link_in=uninstrumented fun:_IO_list_lock=uninstrumented fun:_IO_list_resetlock=uninstrumented fun:_IO_list_unlock=uninstrumented fun:_IO_marker_delta=uninstrumented fun:_IO_marker_difference=uninstrumented fun:_IO_padn=uninstrumented fun:_IO_peekc_locked=uninstrumented fun:_IO_popen=uninstrumented fun:_IO_printf=uninstrumented fun:_IO_proc_close=uninstrumented fun:_IO_proc_open=uninstrumented fun:_IO_putc=uninstrumented fun:_IO_puts=uninstrumented fun:_IO_remove_marker=uninstrumented fun:_IO_seekmark=uninstrumented fun:_IO_seekoff=uninstrumented fun:_IO_seekpos=uninstrumented fun:_IO_seekwmark=uninstrumented fun:_IO_setb=uninstrumented fun:_IO_setbuffer=uninstrumented fun:_IO_setvbuf=uninstrumented fun:_IO_sgetn=uninstrumented fun:_IO_sprintf=uninstrumented fun:_IO_sputbackc=uninstrumented fun:_IO_sputbackwc=uninstrumented fun:_IO_sscanf=uninstrumented fun:_IO_str_init_readonly=uninstrumented fun:_IO_str_init_static=uninstrumented fun:_IO_str_overflow=uninstrumented fun:_IO_str_pbackfail=uninstrumented fun:_IO_str_seekoff=uninstrumented fun:_IO_str_underflow=uninstrumented fun:_IO_sungetc=uninstrumented fun:_IO_sungetwc=uninstrumented fun:_IO_switch_to_get_mode=uninstrumented fun:_IO_switch_to_main_wget_area=uninstrumented fun:_IO_switch_to_wbackup_area=uninstrumented fun:_IO_switch_to_wget_mode=uninstrumented fun:_IO_un_link=uninstrumented fun:_IO_ungetc=uninstrumented fun:_IO_unsave_markers=uninstrumented fun:_IO_unsave_wmarkers=uninstrumented fun:_IO_vfprintf=uninstrumented fun:_IO_vfscanf=uninstrumented fun:_IO_vsprintf=uninstrumented fun:_IO_wdefault_doallocate=uninstrumented fun:_IO_wdefault_finish=uninstrumented fun:_IO_wdefault_pbackfail=uninstrumented fun:_IO_wdefault_uflow=uninstrumented fun:_IO_wdefault_xsgetn=uninstrumented fun:_IO_wdefault_xsputn=uninstrumented fun:_IO_wdo_write=uninstrumented fun:_IO_wdoallocbuf=uninstrumented fun:_IO_wfile_overflow=uninstrumented fun:_IO_wfile_seekoff=uninstrumented fun:_IO_wfile_sync=uninstrumented fun:_IO_wfile_underflow=uninstrumented fun:_IO_wfile_xsputn=uninstrumented fun:_IO_wmarker_delta=uninstrumented fun:_IO_wsetb=uninstrumented fun:_Unwind_Backtrace=uninstrumented fun:_Unwind_DeleteException=uninstrumented fun:_Unwind_FindEnclosingFunction=uninstrumented fun:_Unwind_Find_FDE=uninstrumented fun:_Unwind_ForcedUnwind=uninstrumented fun:_Unwind_GetCFA=uninstrumented fun:_Unwind_GetDataRelBase=uninstrumented fun:_Unwind_GetGR=uninstrumented fun:_Unwind_GetIP=uninstrumented fun:_Unwind_GetIPInfo=uninstrumented fun:_Unwind_GetLanguageSpecificData=uninstrumented fun:_Unwind_GetRegionStart=uninstrumented fun:_Unwind_GetTextRelBase=uninstrumented fun:_Unwind_RaiseException=uninstrumented fun:_Unwind_Resume=uninstrumented fun:_Unwind_Resume_or_Rethrow=uninstrumented fun:_Unwind_SetGR=uninstrumented fun:_Unwind_SetIP=uninstrumented fun:__absvdi2=uninstrumented fun:__absvsi2=uninstrumented fun:__absvti2=uninstrumented fun:__acos_finite=uninstrumented fun:__acosf_finite=uninstrumented fun:__acosh_finite=uninstrumented fun:__acoshf_finite=uninstrumented fun:__acoshl_finite=uninstrumented fun:__acosl_finite=uninstrumented fun:__addtf3=uninstrumented fun:__addvdi3=uninstrumented fun:__addvsi3=uninstrumented fun:__addvti3=uninstrumented fun:__adjtimex=uninstrumented fun:__arch_prctl=uninstrumented fun:__argz_count=uninstrumented fun:__argz_next=uninstrumented fun:__argz_stringify=uninstrumented fun:__ashlti3=uninstrumented fun:__ashrti3=uninstrumented fun:__asin_finite=uninstrumented fun:__asinf_finite=uninstrumented fun:__asinl_finite=uninstrumented fun:__asprintf=uninstrumented fun:__asprintf_chk=uninstrumented fun:__assert=uninstrumented fun:__assert_fail=uninstrumented fun:__assert_perror_fail=uninstrumented fun:__atan2_finite=uninstrumented fun:__atan2f_finite=uninstrumented fun:__atan2l_finite=uninstrumented fun:__atanh_finite=uninstrumented fun:__atanhf_finite=uninstrumented fun:__atanhl_finite=uninstrumented fun:__b64_ntop=uninstrumented fun:__b64_pton=uninstrumented fun:__backtrace=uninstrumented fun:__backtrace_symbols=uninstrumented fun:__backtrace_symbols_fd=uninstrumented fun:__bid128_abs=uninstrumented fun:__bid128_add=uninstrumented fun:__bid128_class=uninstrumented fun:__bid128_copy=uninstrumented fun:__bid128_copySign=uninstrumented fun:__bid128_div=uninstrumented fun:__bid128_fma=uninstrumented fun:__bid128_from_int32=uninstrumented fun:__bid128_from_int64=uninstrumented fun:__bid128_from_uint32=uninstrumented fun:__bid128_from_uint64=uninstrumented fun:__bid128_isCanonical=uninstrumented fun:__bid128_isFinite=uninstrumented fun:__bid128_isInf=uninstrumented fun:__bid128_isNaN=uninstrumented fun:__bid128_isNormal=uninstrumented fun:__bid128_isSignaling=uninstrumented fun:__bid128_isSigned=uninstrumented fun:__bid128_isSubnormal=uninstrumented fun:__bid128_isZero=uninstrumented fun:__bid128_mul=uninstrumented fun:__bid128_negate=uninstrumented fun:__bid128_quiet_equal=uninstrumented fun:__bid128_quiet_greater=uninstrumented fun:__bid128_quiet_greater_equal=uninstrumented fun:__bid128_quiet_greater_unordered=uninstrumented fun:__bid128_quiet_less=uninstrumented fun:__bid128_quiet_less_equal=uninstrumented fun:__bid128_quiet_less_unordered=uninstrumented fun:__bid128_quiet_not_equal=uninstrumented fun:__bid128_quiet_not_greater=uninstrumented fun:__bid128_quiet_not_less=uninstrumented fun:__bid128_quiet_ordered=uninstrumented fun:__bid128_quiet_unordered=uninstrumented fun:__bid128_radix=uninstrumented fun:__bid128_sameQuantum=uninstrumented fun:__bid128_signaling_greater=uninstrumented fun:__bid128_signaling_greater_equal=uninstrumented fun:__bid128_signaling_greater_unordered=uninstrumented fun:__bid128_signaling_less=uninstrumented fun:__bid128_signaling_less_equal=uninstrumented fun:__bid128_signaling_less_unordered=uninstrumented fun:__bid128_signaling_not_greater=uninstrumented fun:__bid128_signaling_not_less=uninstrumented fun:__bid128_sub=uninstrumented fun:__bid128_to_bid32=uninstrumented fun:__bid128_to_bid64=uninstrumented fun:__bid128_to_binary128=uninstrumented fun:__bid128_to_binary32=uninstrumented fun:__bid128_to_binary64=uninstrumented fun:__bid128_to_binary80=uninstrumented fun:__bid128_to_int32_ceil=uninstrumented fun:__bid128_to_int32_floor=uninstrumented fun:__bid128_to_int32_int=uninstrumented fun:__bid128_to_int32_rnint=uninstrumented fun:__bid128_to_int32_rninta=uninstrumented fun:__bid128_to_int32_xceil=uninstrumented fun:__bid128_to_int32_xfloor=uninstrumented fun:__bid128_to_int32_xint=uninstrumented fun:__bid128_to_int32_xrnint=uninstrumented fun:__bid128_to_int32_xrninta=uninstrumented fun:__bid128_to_int64_ceil=uninstrumented fun:__bid128_to_int64_floor=uninstrumented fun:__bid128_to_int64_int=uninstrumented fun:__bid128_to_int64_rnint=uninstrumented fun:__bid128_to_int64_rninta=uninstrumented fun:__bid128_to_int64_xceil=uninstrumented fun:__bid128_to_int64_xfloor=uninstrumented fun:__bid128_to_int64_xint=uninstrumented fun:__bid128_to_int64_xrnint=uninstrumented fun:__bid128_to_int64_xrninta=uninstrumented fun:__bid128_to_uint32_ceil=uninstrumented fun:__bid128_to_uint32_floor=uninstrumented fun:__bid128_to_uint32_int=uninstrumented fun:__bid128_to_uint32_rnint=uninstrumented fun:__bid128_to_uint32_rninta=uninstrumented fun:__bid128_to_uint32_xceil=uninstrumented fun:__bid128_to_uint32_xfloor=uninstrumented fun:__bid128_to_uint32_xint=uninstrumented fun:__bid128_to_uint32_xrnint=uninstrumented fun:__bid128_to_uint32_xrninta=uninstrumented fun:__bid128_to_uint64_ceil=uninstrumented fun:__bid128_to_uint64_floor=uninstrumented fun:__bid128_to_uint64_int=uninstrumented fun:__bid128_to_uint64_rnint=uninstrumented fun:__bid128_to_uint64_rninta=uninstrumented fun:__bid128_to_uint64_xceil=uninstrumented fun:__bid128_to_uint64_xfloor=uninstrumented fun:__bid128_to_uint64_xint=uninstrumented fun:__bid128_to_uint64_xrnint=uninstrumented fun:__bid128_to_uint64_xrninta=uninstrumented fun:__bid128_totalOrder=uninstrumented fun:__bid128_totalOrderMag=uninstrumented fun:__bid128dd_add=uninstrumented fun:__bid128dd_div=uninstrumented fun:__bid128dd_mul=uninstrumented fun:__bid128dd_sub=uninstrumented fun:__bid128ddd_fma=uninstrumented fun:__bid128ddq_fma=uninstrumented fun:__bid128dq_add=uninstrumented fun:__bid128dq_div=uninstrumented fun:__bid128dq_mul=uninstrumented fun:__bid128dq_sub=uninstrumented fun:__bid128dqd_fma=uninstrumented fun:__bid128dqq_fma=uninstrumented fun:__bid128qd_add=uninstrumented fun:__bid128qd_div=uninstrumented fun:__bid128qd_mul=uninstrumented fun:__bid128qd_sub=uninstrumented fun:__bid128qdd_fma=uninstrumented fun:__bid128qdq_fma=uninstrumented fun:__bid128qqd_fma=uninstrumented fun:__bid32_to_bid128=uninstrumented fun:__bid32_to_bid64=uninstrumented fun:__bid32_to_binary128=uninstrumented fun:__bid32_to_binary32=uninstrumented fun:__bid32_to_binary64=uninstrumented fun:__bid32_to_binary80=uninstrumented fun:__bid64_abs=uninstrumented fun:__bid64_add=uninstrumented fun:__bid64_class=uninstrumented fun:__bid64_copy=uninstrumented fun:__bid64_copySign=uninstrumented fun:__bid64_div=uninstrumented fun:__bid64_from_int32=uninstrumented fun:__bid64_from_int64=uninstrumented fun:__bid64_from_uint32=uninstrumented fun:__bid64_from_uint64=uninstrumented fun:__bid64_isCanonical=uninstrumented fun:__bid64_isFinite=uninstrumented fun:__bid64_isInf=uninstrumented fun:__bid64_isNaN=uninstrumented fun:__bid64_isNormal=uninstrumented fun:__bid64_isSignaling=uninstrumented fun:__bid64_isSigned=uninstrumented fun:__bid64_isSubnormal=uninstrumented fun:__bid64_isZero=uninstrumented fun:__bid64_mul=uninstrumented fun:__bid64_negate=uninstrumented fun:__bid64_quiet_equal=uninstrumented fun:__bid64_quiet_greater=uninstrumented fun:__bid64_quiet_greater_equal=uninstrumented fun:__bid64_quiet_greater_unordered=uninstrumented fun:__bid64_quiet_less=uninstrumented fun:__bid64_quiet_less_equal=uninstrumented fun:__bid64_quiet_less_unordered=uninstrumented fun:__bid64_quiet_not_equal=uninstrumented fun:__bid64_quiet_not_greater=uninstrumented fun:__bid64_quiet_not_less=uninstrumented fun:__bid64_quiet_ordered=uninstrumented fun:__bid64_quiet_unordered=uninstrumented fun:__bid64_radix=uninstrumented fun:__bid64_sameQuantum=uninstrumented fun:__bid64_signaling_greater=uninstrumented fun:__bid64_signaling_greater_equal=uninstrumented fun:__bid64_signaling_greater_unordered=uninstrumented fun:__bid64_signaling_less=uninstrumented fun:__bid64_signaling_less_equal=uninstrumented fun:__bid64_signaling_less_unordered=uninstrumented fun:__bid64_signaling_not_greater=uninstrumented fun:__bid64_signaling_not_less=uninstrumented fun:__bid64_sub=uninstrumented fun:__bid64_to_bid128=uninstrumented fun:__bid64_to_bid32=uninstrumented fun:__bid64_to_binary128=uninstrumented fun:__bid64_to_binary32=uninstrumented fun:__bid64_to_binary64=uninstrumented fun:__bid64_to_binary80=uninstrumented fun:__bid64_to_int32_ceil=uninstrumented fun:__bid64_to_int32_floor=uninstrumented fun:__bid64_to_int32_int=uninstrumented fun:__bid64_to_int32_rnint=uninstrumented fun:__bid64_to_int32_rninta=uninstrumented fun:__bid64_to_int32_xceil=uninstrumented fun:__bid64_to_int32_xfloor=uninstrumented fun:__bid64_to_int32_xint=uninstrumented fun:__bid64_to_int32_xrnint=uninstrumented fun:__bid64_to_int32_xrninta=uninstrumented fun:__bid64_to_int64_ceil=uninstrumented fun:__bid64_to_int64_floor=uninstrumented fun:__bid64_to_int64_int=uninstrumented fun:__bid64_to_int64_rnint=uninstrumented fun:__bid64_to_int64_rninta=uninstrumented fun:__bid64_to_int64_xceil=uninstrumented fun:__bid64_to_int64_xfloor=uninstrumented fun:__bid64_to_int64_xint=uninstrumented fun:__bid64_to_int64_xrnint=uninstrumented fun:__bid64_to_int64_xrninta=uninstrumented fun:__bid64_to_uint32_ceil=uninstrumented fun:__bid64_to_uint32_floor=uninstrumented fun:__bid64_to_uint32_int=uninstrumented fun:__bid64_to_uint32_rnint=uninstrumented fun:__bid64_to_uint32_rninta=uninstrumented fun:__bid64_to_uint32_xceil=uninstrumented fun:__bid64_to_uint32_xfloor=uninstrumented fun:__bid64_to_uint32_xint=uninstrumented fun:__bid64_to_uint32_xrnint=uninstrumented fun:__bid64_to_uint32_xrninta=uninstrumented fun:__bid64_to_uint64_ceil=uninstrumented fun:__bid64_to_uint64_floor=uninstrumented fun:__bid64_to_uint64_int=uninstrumented fun:__bid64_to_uint64_rnint=uninstrumented fun:__bid64_to_uint64_rninta=uninstrumented fun:__bid64_to_uint64_xceil=uninstrumented fun:__bid64_to_uint64_xfloor=uninstrumented fun:__bid64_to_uint64_xint=uninstrumented fun:__bid64_to_uint64_xrnint=uninstrumented fun:__bid64_to_uint64_xrninta=uninstrumented fun:__bid64_totalOrder=uninstrumented fun:__bid64_totalOrderMag=uninstrumented fun:__bid64ddq_fma=uninstrumented fun:__bid64dq_add=uninstrumented fun:__bid64dq_div=uninstrumented fun:__bid64dq_mul=uninstrumented fun:__bid64dq_sub=uninstrumented fun:__bid64dqd_fma=uninstrumented fun:__bid64dqq_fma=uninstrumented fun:__bid64qd_add=uninstrumented fun:__bid64qd_div=uninstrumented fun:__bid64qd_mul=uninstrumented fun:__bid64qd_sub=uninstrumented fun:__bid64qdd_fma=uninstrumented fun:__bid64qdq_fma=uninstrumented fun:__bid64qq_add=uninstrumented fun:__bid64qq_div=uninstrumented fun:__bid64qq_mul=uninstrumented fun:__bid64qq_sub=uninstrumented fun:__bid64qqd_fma=uninstrumented fun:__bid64qqq_fma=uninstrumented fun:__bid_adddd3=uninstrumented fun:__bid_addsd3=uninstrumented fun:__bid_addtd3=uninstrumented fun:__bid_divdd3=uninstrumented fun:__bid_divsd3=uninstrumented fun:__bid_divtd3=uninstrumented fun:__bid_eqdd2=uninstrumented fun:__bid_eqsd2=uninstrumented fun:__bid_eqtd2=uninstrumented fun:__bid_extendddtd2=uninstrumented fun:__bid_extendddtf=uninstrumented fun:__bid_extendddxf=uninstrumented fun:__bid_extenddfdd=uninstrumented fun:__bid_extenddftd=uninstrumented fun:__bid_extendsddd2=uninstrumented fun:__bid_extendsddf=uninstrumented fun:__bid_extendsdtd2=uninstrumented fun:__bid_extendsdtf=uninstrumented fun:__bid_extendsdxf=uninstrumented fun:__bid_extendsfdd=uninstrumented fun:__bid_extendsfsd=uninstrumented fun:__bid_extendsftd=uninstrumented fun:__bid_extendtftd=uninstrumented fun:__bid_extendxftd=uninstrumented fun:__bid_fixdddi=uninstrumented fun:__bid_fixddsi=uninstrumented fun:__bid_fixsddi=uninstrumented fun:__bid_fixsdsi=uninstrumented fun:__bid_fixtddi=uninstrumented fun:__bid_fixtdsi=uninstrumented fun:__bid_fixunsdddi=uninstrumented fun:__bid_fixunsddsi=uninstrumented fun:__bid_fixunssddi=uninstrumented fun:__bid_fixunssdsi=uninstrumented fun:__bid_fixunstddi=uninstrumented fun:__bid_fixunstdsi=uninstrumented fun:__bid_floatdidd=uninstrumented fun:__bid_floatdisd=uninstrumented fun:__bid_floatditd=uninstrumented fun:__bid_floatsidd=uninstrumented fun:__bid_floatsisd=uninstrumented fun:__bid_floatsitd=uninstrumented fun:__bid_floatunsdidd=uninstrumented fun:__bid_floatunsdisd=uninstrumented fun:__bid_floatunsditd=uninstrumented fun:__bid_floatunssidd=uninstrumented fun:__bid_floatunssisd=uninstrumented fun:__bid_floatunssitd=uninstrumented fun:__bid_gedd2=uninstrumented fun:__bid_gesd2=uninstrumented fun:__bid_getd2=uninstrumented fun:__bid_gtdd2=uninstrumented fun:__bid_gtsd2=uninstrumented fun:__bid_gttd2=uninstrumented fun:__bid_ledd2=uninstrumented fun:__bid_lesd2=uninstrumented fun:__bid_letd2=uninstrumented fun:__bid_ltdd2=uninstrumented fun:__bid_ltsd2=uninstrumented fun:__bid_lttd2=uninstrumented fun:__bid_muldd3=uninstrumented fun:__bid_mulsd3=uninstrumented fun:__bid_multd3=uninstrumented fun:__bid_nedd2=uninstrumented fun:__bid_nesd2=uninstrumented fun:__bid_netd2=uninstrumented fun:__bid_round128_19_38=uninstrumented fun:__bid_round192_39_57=uninstrumented fun:__bid_round256_58_76=uninstrumented fun:__bid_round64_2_18=uninstrumented fun:__bid_subdd3=uninstrumented fun:__bid_subsd3=uninstrumented fun:__bid_subtd3=uninstrumented fun:__bid_truncdddf=uninstrumented fun:__bid_truncddsd2=uninstrumented fun:__bid_truncddsf=uninstrumented fun:__bid_truncdfsd=uninstrumented fun:__bid_truncsdsf=uninstrumented fun:__bid_trunctddd2=uninstrumented fun:__bid_trunctddf=uninstrumented fun:__bid_trunctdsd2=uninstrumented fun:__bid_trunctdsf=uninstrumented fun:__bid_trunctdtf=uninstrumented fun:__bid_trunctdxf=uninstrumented fun:__bid_trunctfdd=uninstrumented fun:__bid_trunctfsd=uninstrumented fun:__bid_truncxfdd=uninstrumented fun:__bid_truncxfsd=uninstrumented fun:__bid_unorddd2=uninstrumented fun:__bid_unordsd2=uninstrumented fun:__bid_unordtd2=uninstrumented fun:__binary128_to_bid128=uninstrumented fun:__binary128_to_bid32=uninstrumented fun:__binary128_to_bid64=uninstrumented fun:__binary32_to_bid128=uninstrumented fun:__binary32_to_bid32=uninstrumented fun:__binary32_to_bid64=uninstrumented fun:__binary64_to_bid128=uninstrumented fun:__binary64_to_bid32=uninstrumented fun:__binary64_to_bid64=uninstrumented fun:__binary80_to_bid128=uninstrumented fun:__binary80_to_bid32=uninstrumented fun:__binary80_to_bid64=uninstrumented fun:__bsd_getpgrp=uninstrumented fun:__bswapdi2=uninstrumented fun:__bswapsi2=uninstrumented fun:__bzero=uninstrumented fun:__call_tls_dtors=uninstrumented fun:__chk_fail=uninstrumented fun:__clear_cache=uninstrumented fun:__clock_getcpuclockid=uninstrumented fun:__clock_getres=uninstrumented fun:__clock_gettime=uninstrumented fun:__clock_nanosleep=uninstrumented fun:__clock_settime=uninstrumented fun:__clog10=uninstrumented fun:__clog10f=uninstrumented fun:__clog10l=uninstrumented fun:__clone=uninstrumented fun:__close=uninstrumented fun:__clrsbdi2=uninstrumented fun:__clrsbti2=uninstrumented fun:__clzdi2=uninstrumented fun:__clzti2=uninstrumented fun:__cmpti2=uninstrumented fun:__cmsg_nxthdr=uninstrumented fun:__confstr_chk=uninstrumented fun:__connect=uninstrumented fun:__cosh_finite=uninstrumented fun:__coshf_finite=uninstrumented fun:__coshl_finite=uninstrumented fun:__cpu_indicator_init=uninstrumented fun:__create_ib_request=uninstrumented fun:__ctype_b_loc=uninstrumented fun:__ctype_get_mb_cur_max=uninstrumented fun:__ctype_init=uninstrumented fun:__ctype_tolower_loc=uninstrumented fun:__ctype_toupper_loc=uninstrumented fun:__ctzdi2=uninstrumented fun:__ctzti2=uninstrumented fun:__cxa_at_quick_exit=uninstrumented fun:__cxa_atexit=uninstrumented fun:__cxa_finalize=uninstrumented fun:__cxa_thread_atexit_impl=uninstrumented fun:__cyg_profile_func_enter=uninstrumented fun:__cyg_profile_func_exit=uninstrumented fun:__dcgettext=uninstrumented fun:__default_morecore=uninstrumented fun:__deregister_frame=uninstrumented fun:__deregister_frame_info=uninstrumented fun:__deregister_frame_info_bases=uninstrumented fun:__dfp_clear_except=uninstrumented fun:__dfp_get_round=uninstrumented fun:__dfp_raise_except=uninstrumented fun:__dfp_set_round=uninstrumented fun:__dfp_test_except=uninstrumented fun:__dgettext=uninstrumented fun:__divdc3=uninstrumented fun:__divsc3=uninstrumented fun:__divtc3=uninstrumented fun:__divtf3=uninstrumented fun:__divti3=uninstrumented fun:__divxc3=uninstrumented fun:__dn_comp=uninstrumented fun:__dn_count_labels=uninstrumented fun:__dn_expand=uninstrumented fun:__dn_skipname=uninstrumented fun:__do_niscall3=uninstrumented fun:__dprintf_chk=uninstrumented fun:__dup2=uninstrumented fun:__duplocale=uninstrumented fun:__emutls_get_address=uninstrumented fun:__emutls_register_common=uninstrumented fun:__enable_execute_stack=uninstrumented fun:__endmntent=uninstrumented fun:__eprintf=uninstrumented fun:__eqtf2=uninstrumented fun:__errno_location=uninstrumented fun:__exp10_finite=uninstrumented fun:__exp10f_finite=uninstrumented fun:__exp10l_finite=uninstrumented fun:__exp2_finite=uninstrumented fun:__exp2f_finite=uninstrumented fun:__exp2l_finite=uninstrumented fun:__exp_finite=uninstrumented fun:__expf_finite=uninstrumented fun:__expl_finite=uninstrumented fun:__extenddftf2=uninstrumented fun:__extendsftf2=uninstrumented fun:__extendxftf2=uninstrumented fun:__fbufsize=uninstrumented fun:__fcntl=uninstrumented fun:__fdelt_chk=uninstrumented fun:__fdelt_warn=uninstrumented fun:__fentry__=uninstrumented fun:__ffs=uninstrumented fun:__ffsdi2=uninstrumented fun:__ffsti2=uninstrumented fun:__fgets_chk=uninstrumented fun:__fgets_unlocked_chk=uninstrumented fun:__fgetws_chk=uninstrumented fun:__fgetws_unlocked_chk=uninstrumented fun:__finite=uninstrumented fun:__finitef=uninstrumented fun:__finitel=uninstrumented fun:__fixdfti=uninstrumented fun:__fixsfti=uninstrumented fun:__fixtfdi=uninstrumented fun:__fixtfsi=uninstrumented fun:__fixtfti=uninstrumented fun:__fixunsdfdi=uninstrumented fun:__fixunsdfti=uninstrumented fun:__fixunssfdi=uninstrumented fun:__fixunssfti=uninstrumented fun:__fixunstfdi=uninstrumented fun:__fixunstfsi=uninstrumented fun:__fixunstfti=uninstrumented fun:__fixunsxfdi=uninstrumented fun:__fixunsxfti=uninstrumented fun:__fixxfti=uninstrumented fun:__flbf=uninstrumented fun:__floatditf=uninstrumented fun:__floatsitf=uninstrumented fun:__floattidf=uninstrumented fun:__floattisf=uninstrumented fun:__floattitf=uninstrumented fun:__floattixf=uninstrumented fun:__floatunditf=uninstrumented fun:__floatunsitf=uninstrumented fun:__floatuntidf=uninstrumented fun:__floatuntisf=uninstrumented fun:__floatuntitf=uninstrumented fun:__floatuntixf=uninstrumented fun:__fmod_finite=uninstrumented fun:__fmodf_finite=uninstrumented fun:__fmodl_finite=uninstrumented fun:__follow_path=uninstrumented fun:__fork=uninstrumented fun:__fortify_fail=uninstrumented fun:__fp_nquery=uninstrumented fun:__fp_query=uninstrumented fun:__fp_resstat=uninstrumented fun:__fpclassify=uninstrumented fun:__fpclassifyf=uninstrumented fun:__fpclassifyl=uninstrumented fun:__fpending=uninstrumented fun:__fprintf_chk=uninstrumented fun:__fpurge=uninstrumented fun:__fread_chk=uninstrumented fun:__fread_unlocked_chk=uninstrumented fun:__freadable=uninstrumented fun:__freading=uninstrumented fun:__free_fdresult=uninstrumented fun:__freelocale=uninstrumented fun:__fsetlocking=uninstrumented fun:__fstat=uninstrumented fun:__fwprintf_chk=uninstrumented fun:__fwritable=uninstrumented fun:__fwriting=uninstrumented fun:__fxstat=uninstrumented fun:__fxstat64=uninstrumented fun:__fxstatat=uninstrumented fun:__fxstatat64=uninstrumented fun:__gai_sigqueue=uninstrumented fun:__gamma_r_finite=uninstrumented fun:__gammaf_r_finite=uninstrumented fun:__gammal_r_finite=uninstrumented fun:__gcc_bcmp=uninstrumented fun:__gcc_personality_v0=uninstrumented fun:__gconv_get_alias_db=uninstrumented fun:__gconv_get_cache=uninstrumented fun:__gconv_get_modules_db=uninstrumented fun:__generic_findstack=uninstrumented fun:__generic_morestack=uninstrumented fun:__generic_morestack_set_initial_sp=uninstrumented fun:__generic_releasestack=uninstrumented fun:__get_cpu_features=uninstrumented fun:__getauxval=uninstrumented fun:__getcwd_chk=uninstrumented fun:__getdelim=uninstrumented fun:__getdomainname_chk=uninstrumented fun:__getf2=uninstrumented fun:__getgroups_chk=uninstrumented fun:__gethostname_chk=uninstrumented fun:__getlogin_r_chk=uninstrumented fun:__getmntent_r=uninstrumented fun:__getpagesize=uninstrumented fun:__getpgid=uninstrumented fun:__getpid=uninstrumented fun:__gets_chk=uninstrumented fun:__gettimeofday=uninstrumented fun:__getwd_chk=uninstrumented fun:__gmtime_r=uninstrumented fun:__gttf2=uninstrumented fun:__h_errno_location=uninstrumented fun:__hostalias=uninstrumented fun:__hypot_finite=uninstrumented fun:__hypotf_finite=uninstrumented fun:__hypotl_finite=uninstrumented fun:__internal_endnetgrent=uninstrumented fun:__internal_getnetgrent_r=uninstrumented fun:__internal_setnetgrent=uninstrumented fun:__isalnum_l=uninstrumented fun:__isalpha_l=uninstrumented fun:__isascii_l=uninstrumented fun:__isblank_l=uninstrumented fun:__iscntrl_l=uninstrumented fun:__isctype=uninstrumented fun:__isdigit_l=uninstrumented fun:__isgraph_l=uninstrumented fun:__isinf=uninstrumented fun:__isinff=uninstrumented fun:__isinfl=uninstrumented fun:__islower_l=uninstrumented fun:__isnan=uninstrumented fun:__isnanf=uninstrumented fun:__isnanl=uninstrumented fun:__isoc99_fscanf=uninstrumented fun:__isoc99_fwscanf=uninstrumented fun:__isoc99_scanf=uninstrumented fun:__isoc99_sscanf=uninstrumented fun:__isoc99_swscanf=uninstrumented fun:__isoc99_vfscanf=uninstrumented fun:__isoc99_vfwscanf=uninstrumented fun:__isoc99_vscanf=uninstrumented fun:__isoc99_vsscanf=uninstrumented fun:__isoc99_vswscanf=uninstrumented fun:__isoc99_vwscanf=uninstrumented fun:__isoc99_wscanf=uninstrumented fun:__isprint_l=uninstrumented fun:__ispunct_l=uninstrumented fun:__issignaling=uninstrumented fun:__issignalingf=uninstrumented fun:__issignalingl=uninstrumented fun:__isspace_l=uninstrumented fun:__isupper_l=uninstrumented fun:__iswalnum_l=uninstrumented fun:__iswalpha_l=uninstrumented fun:__iswblank_l=uninstrumented fun:__iswcntrl_l=uninstrumented fun:__iswctype=uninstrumented fun:__iswctype_l=uninstrumented fun:__iswdigit_l=uninstrumented fun:__iswgraph_l=uninstrumented fun:__iswlower_l=uninstrumented fun:__iswprint_l=uninstrumented fun:__iswpunct_l=uninstrumented fun:__iswspace_l=uninstrumented fun:__iswupper_l=uninstrumented fun:__iswxdigit_l=uninstrumented fun:__isxdigit_l=uninstrumented fun:__ivaliduser=uninstrumented fun:__j0_finite=uninstrumented fun:__j0f_finite=uninstrumented fun:__j0l_finite=uninstrumented fun:__j1_finite=uninstrumented fun:__j1f_finite=uninstrumented fun:__j1l_finite=uninstrumented fun:__jn_finite=uninstrumented fun:__jnf_finite=uninstrumented fun:__jnl_finite=uninstrumented fun:__letf2=uninstrumented fun:__lgamma_r_finite=uninstrumented fun:__lgammaf_r_finite=uninstrumented fun:__lgammal_r_finite=uninstrumented fun:__libc_alloca_cutoff=uninstrumented fun:__libc_allocate_rtsig=uninstrumented fun:__libc_allocate_rtsig_private=uninstrumented fun:__libc_calloc=uninstrumented fun:__libc_clntudp_bufcreate=uninstrumented fun:__libc_csu_fini=uninstrumented fun:__libc_csu_init=uninstrumented fun:__libc_current_sigrtmax=uninstrumented fun:__libc_current_sigrtmax_private=uninstrumented fun:__libc_current_sigrtmin=uninstrumented fun:__libc_current_sigrtmin_private=uninstrumented fun:__libc_dl_error_tsd=uninstrumented fun:__libc_dlclose=uninstrumented fun:__libc_dlopen_mode=uninstrumented fun:__libc_dlsym=uninstrumented fun:__libc_fatal=uninstrumented fun:__libc_fork=uninstrumented fun:__libc_free=uninstrumented fun:__libc_freeres=uninstrumented fun:__libc_ifunc_impl_list=uninstrumented fun:__libc_init_first=uninstrumented fun:__libc_longjmp=uninstrumented fun:__libc_mallinfo=uninstrumented fun:__libc_malloc=uninstrumented fun:__libc_mallopt=uninstrumented fun:__libc_memalign=uninstrumented fun:__libc_pthread_init=uninstrumented fun:__libc_pvalloc=uninstrumented fun:__libc_pwrite=uninstrumented fun:__libc_realloc=uninstrumented fun:__libc_res_nquery=uninstrumented fun:__libc_res_nsearch=uninstrumented fun:__libc_rpc_getport=uninstrumented fun:__libc_sa_len=uninstrumented fun:__libc_secure_getenv=uninstrumented fun:__libc_siglongjmp=uninstrumented fun:__libc_start_main=uninstrumented fun:__libc_system=uninstrumented fun:__libc_thread_freeres=uninstrumented fun:__libc_valloc=uninstrumented fun:__loc_aton=uninstrumented fun:__loc_ntoa=uninstrumented fun:__log10_finite=uninstrumented fun:__log10f_finite=uninstrumented fun:__log10l_finite=uninstrumented fun:__log2_finite=uninstrumented fun:__log2f_finite=uninstrumented fun:__log2l_finite=uninstrumented fun:__log_finite=uninstrumented fun:__logf_finite=uninstrumented fun:__logl_finite=uninstrumented fun:__longjmp_chk=uninstrumented fun:__lseek=uninstrumented fun:__lshrti3=uninstrumented fun:__lstat=uninstrumented fun:__lttf2=uninstrumented fun:__lxstat=uninstrumented fun:__lxstat64=uninstrumented fun:__madvise=uninstrumented fun:__mbrlen=uninstrumented fun:__mbrtowc=uninstrumented fun:__mbsnrtowcs_chk=uninstrumented fun:__mbsrtowcs_chk=uninstrumented fun:__mbstowcs_chk=uninstrumented fun:__memcpy_chk=uninstrumented fun:__memmove_chk=uninstrumented fun:__mempcpy=uninstrumented fun:__mempcpy_chk=uninstrumented fun:__mempcpy_small=uninstrumented fun:__memset_chk=uninstrumented fun:__mknod=uninstrumented fun:__mktemp=uninstrumented fun:__modti3=uninstrumented fun:__monstartup=uninstrumented fun:__morestack=uninstrumented fun:__morestack_allocate_stack_space=uninstrumented fun:__morestack_block_signals=uninstrumented fun:__morestack_fail=uninstrumented fun:__morestack_get_guard=uninstrumented fun:__morestack_large_model=uninstrumented fun:__morestack_load_mmap=uninstrumented fun:__morestack_make_guard=uninstrumented fun:__morestack_non_split=uninstrumented fun:__morestack_release_segments=uninstrumented fun:__morestack_set_guard=uninstrumented fun:__morestack_unblock_signals=uninstrumented fun:__mq_open_2=uninstrumented fun:__muldc3=uninstrumented fun:__mulsc3=uninstrumented fun:__multc3=uninstrumented fun:__multf3=uninstrumented fun:__multi3=uninstrumented fun:__mulvdi3=uninstrumented fun:__mulvsi3=uninstrumented fun:__mulvti3=uninstrumented fun:__mulxc3=uninstrumented fun:__nanosleep=uninstrumented fun:__negtf2=uninstrumented fun:__negti2=uninstrumented fun:__negvdi2=uninstrumented fun:__negvsi2=uninstrumented fun:__negvti2=uninstrumented fun:__netf2=uninstrumented fun:__newlocale=uninstrumented fun:__nis_default_access=uninstrumented fun:__nis_default_group=uninstrumented fun:__nis_default_owner=uninstrumented fun:__nis_default_ttl=uninstrumented fun:__nis_finddirectory=uninstrumented fun:__nis_hash=uninstrumented fun:__nisbind_connect=uninstrumented fun:__nisbind_create=uninstrumented fun:__nisbind_destroy=uninstrumented fun:__nisbind_next=uninstrumented fun:__nl_langinfo_l=uninstrumented fun:__ns_get16=uninstrumented fun:__ns_get32=uninstrumented fun:__ns_name_ntop=uninstrumented fun:__ns_name_unpack=uninstrumented fun:__nss_configure_lookup=uninstrumented fun:__nss_database_lookup=uninstrumented fun:__nss_disable_nscd=uninstrumented fun:__nss_group_lookup=uninstrumented fun:__nss_group_lookup2=uninstrumented fun:__nss_hostname_digits_dots=uninstrumented fun:__nss_hosts_lookup=uninstrumented fun:__nss_hosts_lookup2=uninstrumented fun:__nss_lookup=uninstrumented fun:__nss_lookup_function=uninstrumented fun:__nss_next=uninstrumented fun:__nss_next2=uninstrumented fun:__nss_passwd_lookup=uninstrumented fun:__nss_passwd_lookup2=uninstrumented fun:__nss_services_lookup2=uninstrumented fun:__obstack_printf_chk=uninstrumented fun:__obstack_vprintf_chk=uninstrumented fun:__open=uninstrumented fun:__open64=uninstrumented fun:__open64_2=uninstrumented fun:__open_2=uninstrumented fun:__open_catalog=uninstrumented fun:__openat64_2=uninstrumented fun:__openat_2=uninstrumented fun:__overflow=uninstrumented fun:__p_cdname=uninstrumented fun:__p_cdnname=uninstrumented fun:__p_class=uninstrumented fun:__p_fqname=uninstrumented fun:__p_fqnname=uninstrumented fun:__p_option=uninstrumented fun:__p_query=uninstrumented fun:__p_rcode=uninstrumented fun:__p_secstodate=uninstrumented fun:__p_time=uninstrumented fun:__p_type=uninstrumented fun:__paritydi2=uninstrumented fun:__parityti2=uninstrumented fun:__pipe=uninstrumented fun:__poll=uninstrumented fun:__poll_chk=uninstrumented fun:__popcountdi2=uninstrumented fun:__popcountti2=uninstrumented fun:__posix_getopt=uninstrumented fun:__pow_finite=uninstrumented fun:__powf_finite=uninstrumented fun:__powidf2=uninstrumented fun:__powisf2=uninstrumented fun:__powitf2=uninstrumented fun:__powixf2=uninstrumented fun:__powl_finite=uninstrumented fun:__ppoll_chk=uninstrumented fun:__pread64=uninstrumented fun:__pread64_chk=uninstrumented fun:__pread_chk=uninstrumented fun:__prepare_niscall=uninstrumented fun:__printf_chk=uninstrumented fun:__printf_fp=uninstrumented fun:__profile_frequency=uninstrumented fun:__pthread_atfork=uninstrumented fun:__pthread_cleanup_routine=uninstrumented fun:__pthread_clock_gettime=uninstrumented fun:__pthread_clock_settime=uninstrumented fun:__pthread_get_minstack=uninstrumented fun:__pthread_getspecific=uninstrumented fun:__pthread_initialize_minimal=uninstrumented fun:__pthread_key_create=uninstrumented fun:__pthread_mutex_destroy=uninstrumented fun:__pthread_mutex_init=uninstrumented fun:__pthread_mutex_lock=uninstrumented fun:__pthread_mutex_trylock=uninstrumented fun:__pthread_mutex_unlock=uninstrumented fun:__pthread_mutexattr_destroy=uninstrumented fun:__pthread_mutexattr_init=uninstrumented fun:__pthread_mutexattr_settype=uninstrumented fun:__pthread_once=uninstrumented fun:__pthread_register_cancel=uninstrumented fun:__pthread_register_cancel_defer=uninstrumented fun:__pthread_rwlock_destroy=uninstrumented fun:__pthread_rwlock_init=uninstrumented fun:__pthread_rwlock_rdlock=uninstrumented fun:__pthread_rwlock_tryrdlock=uninstrumented fun:__pthread_rwlock_trywrlock=uninstrumented fun:__pthread_rwlock_unlock=uninstrumented fun:__pthread_rwlock_wrlock=uninstrumented fun:__pthread_setspecific=uninstrumented fun:__pthread_unregister_cancel=uninstrumented fun:__pthread_unregister_cancel_restore=uninstrumented fun:__pthread_unwind=uninstrumented fun:__pthread_unwind_next=uninstrumented fun:__ptsname_r_chk=uninstrumented fun:__putlong=uninstrumented fun:__putshort=uninstrumented fun:__pwrite64=uninstrumented fun:__rawmemchr=uninstrumented fun:__read=uninstrumented fun:__read_chk=uninstrumented fun:__readlink_chk=uninstrumented fun:__readlinkat_chk=uninstrumented fun:__realpath_chk=uninstrumented fun:__recv_chk=uninstrumented fun:__recvfrom_chk=uninstrumented fun:__register_atfork=uninstrumented fun:__register_frame=uninstrumented fun:__register_frame_info=uninstrumented fun:__register_frame_info_bases=uninstrumented fun:__register_frame_info_table=uninstrumented fun:__register_frame_info_table_bases=uninstrumented fun:__register_frame_table=uninstrumented fun:__remainder_finite=uninstrumented fun:__remainderf_finite=uninstrumented fun:__remainderl_finite=uninstrumented fun:__res_close=uninstrumented fun:__res_dnok=uninstrumented fun:__res_hnok=uninstrumented fun:__res_hostalias=uninstrumented fun:__res_iclose=uninstrumented fun:__res_init=uninstrumented fun:__res_isourserver=uninstrumented fun:__res_mailok=uninstrumented fun:__res_maybe_init=uninstrumented fun:__res_mkquery=uninstrumented fun:__res_nameinquery=uninstrumented fun:__res_nclose=uninstrumented fun:__res_ninit=uninstrumented fun:__res_nmkquery=uninstrumented fun:__res_nquery=uninstrumented fun:__res_nquerydomain=uninstrumented fun:__res_nsearch=uninstrumented fun:__res_nsend=uninstrumented fun:__res_ownok=uninstrumented fun:__res_queriesmatch=uninstrumented fun:__res_query=uninstrumented fun:__res_querydomain=uninstrumented fun:__res_randomid=uninstrumented fun:__res_search=uninstrumented fun:__res_send=uninstrumented fun:__res_state=uninstrumented fun:__rpc_thread_createerr=uninstrumented fun:__rpc_thread_svc_fdset=uninstrumented fun:__rpc_thread_svc_max_pollfd=uninstrumented fun:__rpc_thread_svc_pollfd=uninstrumented fun:__sbrk=uninstrumented fun:__scalb_finite=uninstrumented fun:__scalbf_finite=uninstrumented fun:__scalbl_finite=uninstrumented fun:__sched_cpualloc=uninstrumented fun:__sched_cpucount=uninstrumented fun:__sched_cpufree=uninstrumented fun:__sched_get_priority_max=uninstrumented fun:__sched_get_priority_min=uninstrumented fun:__sched_getparam=uninstrumented fun:__sched_getscheduler=uninstrumented fun:__sched_setscheduler=uninstrumented fun:__sched_yield=uninstrumented fun:__secure_getenv=uninstrumented fun:__select=uninstrumented fun:__send=uninstrumented fun:__sendmmsg=uninstrumented fun:__setmntent=uninstrumented fun:__setpgid=uninstrumented fun:__sfp_handle_exceptions=uninstrumented fun:__sigaction=uninstrumented fun:__sigaddset=uninstrumented fun:__sigdelset=uninstrumented fun:__sigismember=uninstrumented fun:__signbit=uninstrumented fun:__signbitf=uninstrumented fun:__signbitl=uninstrumented fun:__sigpause=uninstrumented fun:__sigsetjmp=uninstrumented fun:__sigsuspend=uninstrumented fun:__sinh_finite=uninstrumented fun:__sinhf_finite=uninstrumented fun:__sinhl_finite=uninstrumented fun:__snprintf_chk=uninstrumented fun:__splitstack_block_signals=uninstrumented fun:__splitstack_block_signals_context=uninstrumented fun:__splitstack_find=uninstrumented fun:__splitstack_find_context=uninstrumented fun:__splitstack_getcontext=uninstrumented fun:__splitstack_makecontext=uninstrumented fun:__splitstack_releasecontext=uninstrumented fun:__splitstack_resetcontext=uninstrumented fun:__splitstack_setcontext=uninstrumented fun:__sprintf_chk=uninstrumented fun:__sqrt_finite=uninstrumented fun:__sqrtf_finite=uninstrumented fun:__sqrtl_finite=uninstrumented fun:__stack_chk_fail=uninstrumented fun:__stack_chk_fail_local=uninstrumented fun:__stack_split_initialize=uninstrumented fun:__stat=uninstrumented fun:__statfs=uninstrumented fun:__stpcpy=uninstrumented fun:__stpcpy_chk=uninstrumented fun:__stpcpy_small=uninstrumented fun:__stpncpy=uninstrumented fun:__stpncpy_chk=uninstrumented fun:__strcasecmp=uninstrumented fun:__strcasecmp_l=uninstrumented fun:__strcasestr=uninstrumented fun:__strcat_chk=uninstrumented fun:__strcoll_l=uninstrumented fun:__strcpy_chk=uninstrumented fun:__strcpy_small=uninstrumented fun:__strcspn_c1=uninstrumented fun:__strcspn_c2=uninstrumented fun:__strcspn_c3=uninstrumented fun:__strdup=uninstrumented fun:__strerror_r=uninstrumented fun:__strfmon_l=uninstrumented fun:__strftime_l=uninstrumented fun:__strncasecmp_l=uninstrumented fun:__strncat_chk=uninstrumented fun:__strncpy_chk=uninstrumented fun:__strndup=uninstrumented fun:__strpbrk_c2=uninstrumented fun:__strpbrk_c3=uninstrumented fun:__strsep_1c=uninstrumented fun:__strsep_2c=uninstrumented fun:__strsep_3c=uninstrumented fun:__strsep_g=uninstrumented fun:__strspn_c1=uninstrumented fun:__strspn_c2=uninstrumented fun:__strspn_c3=uninstrumented fun:__strtod_internal=uninstrumented fun:__strtod_l=uninstrumented fun:__strtof_internal=uninstrumented fun:__strtof_l=uninstrumented fun:__strtok_r=uninstrumented fun:__strtok_r_1c=uninstrumented fun:__strtol_internal=uninstrumented fun:__strtol_l=uninstrumented fun:__strtold_internal=uninstrumented fun:__strtold_l=uninstrumented fun:__strtoll_internal=uninstrumented fun:__strtoll_l=uninstrumented fun:__strtoul_internal=uninstrumented fun:__strtoul_l=uninstrumented fun:__strtoull_internal=uninstrumented fun:__strtoull_l=uninstrumented fun:__strverscmp=uninstrumented fun:__strxfrm_l=uninstrumented fun:__subtf3=uninstrumented fun:__subvdi3=uninstrumented fun:__subvsi3=uninstrumented fun:__subvti3=uninstrumented fun:__swprintf_chk=uninstrumented fun:__sym_ntop=uninstrumented fun:__sym_ntos=uninstrumented fun:__sym_ston=uninstrumented fun:__sysconf=uninstrumented fun:__sysctl=uninstrumented fun:__syslog_chk=uninstrumented fun:__sysv_signal=uninstrumented fun:__tls_get_addr=uninstrumented fun:__toascii_l=uninstrumented fun:__tolower_l=uninstrumented fun:__toupper_l=uninstrumented fun:__towctrans=uninstrumented fun:__towctrans_l=uninstrumented fun:__towlower_l=uninstrumented fun:__towupper_l=uninstrumented fun:__trunctfdf2=uninstrumented fun:__trunctfsf2=uninstrumented fun:__trunctfxf2=uninstrumented fun:__ttyname_r_chk=uninstrumented fun:__ucmpti2=uninstrumented fun:__udiv_w_sdiv=uninstrumented fun:__udivmodti4=uninstrumented fun:__udivti3=uninstrumented fun:__uflow=uninstrumented fun:__umodti3=uninstrumented fun:__underflow=uninstrumented fun:__unordtf2=uninstrumented fun:__uselocale=uninstrumented fun:__vasprintf_chk=uninstrumented fun:__vdprintf_chk=uninstrumented fun:__vfork=uninstrumented fun:__vfprintf_chk=uninstrumented fun:__vfscanf=uninstrumented fun:__vfwprintf_chk=uninstrumented fun:__vprintf_chk=uninstrumented fun:__vsnprintf=uninstrumented fun:__vsnprintf_chk=uninstrumented fun:__vsprintf_chk=uninstrumented fun:__vsscanf=uninstrumented fun:__vswprintf_chk=uninstrumented fun:__vsyslog_chk=uninstrumented fun:__vwprintf_chk=uninstrumented fun:__wait=uninstrumented fun:__waitpid=uninstrumented fun:__warn_memset_zero_len=uninstrumented fun:__wcpcpy_chk=uninstrumented fun:__wcpncpy_chk=uninstrumented fun:__wcrtomb_chk=uninstrumented fun:__wcscasecmp_l=uninstrumented fun:__wcscat_chk=uninstrumented fun:__wcscoll_l=uninstrumented fun:__wcscpy_chk=uninstrumented fun:__wcsftime_l=uninstrumented fun:__wcsncasecmp_l=uninstrumented fun:__wcsncat_chk=uninstrumented fun:__wcsncpy_chk=uninstrumented fun:__wcsnrtombs_chk=uninstrumented fun:__wcsrtombs_chk=uninstrumented fun:__wcstod_internal=uninstrumented fun:__wcstod_l=uninstrumented fun:__wcstof_internal=uninstrumented fun:__wcstof_l=uninstrumented fun:__wcstol_internal=uninstrumented fun:__wcstol_l=uninstrumented fun:__wcstold_internal=uninstrumented fun:__wcstold_l=uninstrumented fun:__wcstoll_internal=uninstrumented fun:__wcstoll_l=uninstrumented fun:__wcstombs_chk=uninstrumented fun:__wcstoul_internal=uninstrumented fun:__wcstoul_l=uninstrumented fun:__wcstoull_internal=uninstrumented fun:__wcstoull_l=uninstrumented fun:__wcsxfrm_l=uninstrumented fun:__wctomb_chk=uninstrumented fun:__wctrans_l=uninstrumented fun:__wctype_l=uninstrumented fun:__wmemcpy_chk=uninstrumented fun:__wmemmove_chk=uninstrumented fun:__wmempcpy_chk=uninstrumented fun:__wmemset_chk=uninstrumented fun:__woverflow=uninstrumented fun:__wprintf_chk=uninstrumented fun:__wrap_pthread_create=uninstrumented fun:__write=uninstrumented fun:__wuflow=uninstrumented fun:__wunderflow=uninstrumented fun:__xmknod=uninstrumented fun:__xmknodat=uninstrumented fun:__xpg_basename=uninstrumented fun:__xpg_sigpause=uninstrumented fun:__xpg_strerror_r=uninstrumented fun:__xstat=uninstrumented fun:__xstat64=uninstrumented fun:__y0_finite=uninstrumented fun:__y0f_finite=uninstrumented fun:__y0l_finite=uninstrumented fun:__y1_finite=uninstrumented fun:__y1f_finite=uninstrumented fun:__y1l_finite=uninstrumented fun:__yn_finite=uninstrumented fun:__ynf_finite=uninstrumented fun:__ynl_finite=uninstrumented fun:__yp_check=uninstrumented fun:_authenticate=uninstrumented fun:_dl_addr=uninstrumented fun:_dl_allocate_tls=uninstrumented fun:_dl_allocate_tls_init=uninstrumented fun:_dl_deallocate_tls=uninstrumented fun:_dl_debug_state=uninstrumented fun:_dl_find_dso_for_object=uninstrumented fun:_dl_get_tls_static_info=uninstrumented fun:_dl_make_stack_executable=uninstrumented fun:_dl_mcount=uninstrumented fun:_dl_mcount_wrapper=uninstrumented fun:_dl_mcount_wrapper_check=uninstrumented fun:_dl_rtld_di_serinfo=uninstrumented fun:_dl_sym=uninstrumented fun:_dl_tls_setup=uninstrumented fun:_dl_vsym=uninstrumented fun:_exit=uninstrumented fun:_flushlbf=uninstrumented fun:_gethtbyaddr=uninstrumented fun:_gethtbyname=uninstrumented fun:_gethtbyname2=uninstrumented fun:_gethtent=uninstrumented fun:_getlong=uninstrumented fun:_getshort=uninstrumented fun:_longjmp=uninstrumented fun:_mcleanup=uninstrumented fun:_mcount=uninstrumented fun:_nsl_default_nss=uninstrumented fun:_nss_files_parse_grent=uninstrumented fun:_nss_files_parse_pwent=uninstrumented fun:_nss_files_parse_sgent=uninstrumented fun:_nss_files_parse_spent=uninstrumented fun:_obstack_allocated_p=uninstrumented fun:_obstack_begin=uninstrumented fun:_obstack_begin_1=uninstrumented fun:_obstack_free=uninstrumented fun:_obstack_memory_used=uninstrumented fun:_obstack_newchunk=uninstrumented fun:_pthread_cleanup_pop=uninstrumented fun:_pthread_cleanup_pop_restore=uninstrumented fun:_pthread_cleanup_push=uninstrumented fun:_pthread_cleanup_push_defer=uninstrumented fun:_rpc_dtablesize=uninstrumented fun:_seterr_reply=uninstrumented fun:_sethtent=uninstrumented fun:_setjmp=uninstrumented fun:_tolower=uninstrumented fun:_toupper=uninstrumented fun:_xdr_ib_request=uninstrumented fun:_xdr_nis_result=uninstrumented fun:a64l=uninstrumented fun:abort=uninstrumented fun:abs=uninstrumented fun:accept=uninstrumented fun:accept4=uninstrumented fun:access=uninstrumented fun:acct=uninstrumented fun:acos=uninstrumented fun:acosf=uninstrumented fun:acosh=uninstrumented fun:acoshf=uninstrumented fun:acoshl=uninstrumented fun:acosl=uninstrumented fun:addmntent=uninstrumented fun:addseverity=uninstrumented fun:adjtime=uninstrumented fun:adjtimex=uninstrumented fun:advance=uninstrumented fun:aio_cancel=uninstrumented fun:aio_cancel64=uninstrumented fun:aio_error=uninstrumented fun:aio_error64=uninstrumented fun:aio_fsync=uninstrumented fun:aio_fsync64=uninstrumented fun:aio_init=uninstrumented fun:aio_read=uninstrumented fun:aio_read64=uninstrumented fun:aio_return=uninstrumented fun:aio_return64=uninstrumented fun:aio_suspend=uninstrumented fun:aio_suspend64=uninstrumented fun:aio_write=uninstrumented fun:aio_write64=uninstrumented fun:alarm=uninstrumented fun:aligned_alloc=uninstrumented fun:alphasort=uninstrumented fun:alphasort64=uninstrumented fun:arch_prctl=uninstrumented fun:argp_error=uninstrumented fun:argp_failure=uninstrumented fun:argp_help=uninstrumented fun:argp_parse=uninstrumented fun:argp_state_help=uninstrumented fun:argp_usage=uninstrumented fun:argz_add=uninstrumented fun:argz_add_sep=uninstrumented fun:argz_append=uninstrumented fun:argz_count=uninstrumented fun:argz_create=uninstrumented fun:argz_create_sep=uninstrumented fun:argz_delete=uninstrumented fun:argz_extract=uninstrumented fun:argz_insert=uninstrumented fun:argz_next=uninstrumented fun:argz_replace=uninstrumented fun:argz_stringify=uninstrumented fun:asctime=uninstrumented fun:asctime_r=uninstrumented fun:asin=uninstrumented fun:asinf=uninstrumented fun:asinh=uninstrumented fun:asinhf=uninstrumented fun:asinhl=uninstrumented fun:asinl=uninstrumented fun:asprintf=uninstrumented fun:at_quick_exit=uninstrumented fun:atan=uninstrumented fun:atan2=uninstrumented fun:atan2f=uninstrumented fun:atan2l=uninstrumented fun:atanf=uninstrumented fun:atanh=uninstrumented fun:atanhf=uninstrumented fun:atanhl=uninstrumented fun:atanl=uninstrumented fun:atexit=uninstrumented fun:atof=uninstrumented fun:atoi=uninstrumented fun:atol=uninstrumented fun:atoll=uninstrumented fun:authdes_create=uninstrumented fun:authdes_getucred=uninstrumented fun:authdes_pk_create=uninstrumented fun:authnone_create=uninstrumented fun:authunix_create=uninstrumented fun:authunix_create_default=uninstrumented fun:backtrace=uninstrumented fun:backtrace_symbols=uninstrumented fun:backtrace_symbols_fd=uninstrumented fun:basename=uninstrumented fun:bcmp=uninstrumented fun:bcopy=uninstrumented fun:bdflush=uninstrumented fun:bind=uninstrumented fun:bind_textdomain_codeset=uninstrumented fun:bindresvport=uninstrumented fun:bindtextdomain=uninstrumented fun:brk=uninstrumented fun:bsd_signal=uninstrumented fun:bsearch=uninstrumented fun:btowc=uninstrumented fun:bzero=uninstrumented fun:c16rtomb=uninstrumented fun:c32rtomb=uninstrumented fun:cabs=uninstrumented fun:cabsf=uninstrumented fun:cabsl=uninstrumented fun:cacos=uninstrumented fun:cacosf=uninstrumented fun:cacosh=uninstrumented fun:cacoshf=uninstrumented fun:cacoshl=uninstrumented fun:cacosl=uninstrumented fun:calloc=uninstrumented fun:callrpc=uninstrumented fun:canonicalize_file_name=uninstrumented fun:capget=uninstrumented fun:capset=uninstrumented fun:carg=uninstrumented fun:cargf=uninstrumented fun:cargl=uninstrumented fun:casin=uninstrumented fun:casinf=uninstrumented fun:casinh=uninstrumented fun:casinhf=uninstrumented fun:casinhl=uninstrumented fun:casinl=uninstrumented fun:catan=uninstrumented fun:catanf=uninstrumented fun:catanh=uninstrumented fun:catanhf=uninstrumented fun:catanhl=uninstrumented fun:catanl=uninstrumented fun:catclose=uninstrumented fun:catgets=uninstrumented fun:catopen=uninstrumented fun:cbc_crypt=uninstrumented fun:cbrt=uninstrumented fun:cbrtf=uninstrumented fun:cbrtl=uninstrumented fun:ccos=uninstrumented fun:ccosf=uninstrumented fun:ccosh=uninstrumented fun:ccoshf=uninstrumented fun:ccoshl=uninstrumented fun:ccosl=uninstrumented fun:ceil=uninstrumented fun:ceilf=uninstrumented fun:ceill=uninstrumented fun:cexp=uninstrumented fun:cexpf=uninstrumented fun:cexpl=uninstrumented fun:cfgetispeed=uninstrumented fun:cfgetospeed=uninstrumented fun:cfmakeraw=uninstrumented fun:cfree=uninstrumented fun:cfsetispeed=uninstrumented fun:cfsetospeed=uninstrumented fun:cfsetspeed=uninstrumented fun:chdir=uninstrumented fun:chflags=uninstrumented fun:chmod=uninstrumented fun:chown=uninstrumented fun:chroot=uninstrumented fun:cimag=uninstrumented fun:cimagf=uninstrumented fun:cimagl=uninstrumented fun:clearenv=uninstrumented fun:clearerr=uninstrumented fun:clearerr_unlocked=uninstrumented fun:clnt_broadcast=uninstrumented fun:clnt_create=uninstrumented fun:clnt_pcreateerror=uninstrumented fun:clnt_perrno=uninstrumented fun:clnt_perror=uninstrumented fun:clnt_spcreateerror=uninstrumented fun:clnt_sperrno=uninstrumented fun:clnt_sperror=uninstrumented fun:clntraw_create=uninstrumented fun:clnttcp_create=uninstrumented fun:clntudp_bufcreate=uninstrumented fun:clntudp_create=uninstrumented fun:clntunix_create=uninstrumented fun:clock=uninstrumented fun:clock_adjtime=uninstrumented fun:clock_getcpuclockid=uninstrumented fun:clock_getres=uninstrumented fun:clock_gettime=uninstrumented fun:clock_nanosleep=uninstrumented fun:clock_settime=uninstrumented fun:clog=uninstrumented fun:clog10=uninstrumented fun:clog10f=uninstrumented fun:clog10l=uninstrumented fun:clogf=uninstrumented fun:clogl=uninstrumented fun:clone=uninstrumented fun:close=uninstrumented fun:closedir=uninstrumented fun:closelog=uninstrumented fun:confstr=uninstrumented fun:conj=uninstrumented fun:conjf=uninstrumented fun:conjl=uninstrumented fun:connect=uninstrumented fun:copysign=uninstrumented fun:copysignf=uninstrumented fun:copysignl=uninstrumented fun:cos=uninstrumented fun:cosf=uninstrumented fun:cosh=uninstrumented fun:coshf=uninstrumented fun:coshl=uninstrumented fun:cosl=uninstrumented fun:cpow=uninstrumented fun:cpowf=uninstrumented fun:cpowl=uninstrumented fun:cproj=uninstrumented fun:cprojf=uninstrumented fun:cprojl=uninstrumented fun:creal=uninstrumented fun:crealf=uninstrumented fun:creall=uninstrumented fun:creat=uninstrumented fun:creat64=uninstrumented fun:create_module=uninstrumented fun:crypt=uninstrumented fun:crypt_r=uninstrumented fun:csin=uninstrumented fun:csinf=uninstrumented fun:csinh=uninstrumented fun:csinhf=uninstrumented fun:csinhl=uninstrumented fun:csinl=uninstrumented fun:csqrt=uninstrumented fun:csqrtf=uninstrumented fun:csqrtl=uninstrumented fun:ctan=uninstrumented fun:ctanf=uninstrumented fun:ctanh=uninstrumented fun:ctanhf=uninstrumented fun:ctanhl=uninstrumented fun:ctanl=uninstrumented fun:ctermid=uninstrumented fun:ctime=uninstrumented fun:ctime_r=uninstrumented fun:cuserid=uninstrumented fun:daemon=uninstrumented fun:dcgettext=uninstrumented fun:dcngettext=uninstrumented fun:delete_module=uninstrumented fun:des_setparity=uninstrumented fun:dgettext=uninstrumented fun:difftime=uninstrumented fun:dirfd=uninstrumented fun:dirname=uninstrumented fun:div=uninstrumented fun:dl_iterate_phdr=uninstrumented fun:dladdr=uninstrumented fun:dladdr1=uninstrumented fun:dlclose=uninstrumented fun:dlerror=uninstrumented fun:dlinfo=uninstrumented fun:dlmopen=uninstrumented fun:dlopen=uninstrumented fun:dlsym=uninstrumented fun:dlvsym=uninstrumented fun:dngettext=uninstrumented fun:dprintf=uninstrumented fun:drand48=uninstrumented fun:drand48_r=uninstrumented fun:drem=uninstrumented fun:dremf=uninstrumented fun:dreml=uninstrumented fun:dup=uninstrumented fun:dup2=uninstrumented fun:dup3=uninstrumented fun:duplocale=uninstrumented fun:dysize=uninstrumented fun:eaccess=uninstrumented fun:ecb_crypt=uninstrumented fun:ecvt=uninstrumented fun:ecvt_r=uninstrumented fun:encrypt=uninstrumented fun:encrypt_r=uninstrumented fun:endaliasent=uninstrumented fun:endfsent=uninstrumented fun:endgrent=uninstrumented fun:endhostent=uninstrumented fun:endmntent=uninstrumented fun:endnetent=uninstrumented fun:endnetgrent=uninstrumented fun:endprotoent=uninstrumented fun:endpwent=uninstrumented fun:endrpcent=uninstrumented fun:endservent=uninstrumented fun:endsgent=uninstrumented fun:endspent=uninstrumented fun:endttyent=uninstrumented fun:endusershell=uninstrumented fun:endutent=uninstrumented fun:endutxent=uninstrumented fun:envz_add=uninstrumented fun:envz_entry=uninstrumented fun:envz_get=uninstrumented fun:envz_merge=uninstrumented fun:envz_remove=uninstrumented fun:envz_strip=uninstrumented fun:epoll_create=uninstrumented fun:epoll_create1=uninstrumented fun:epoll_ctl=uninstrumented fun:epoll_pwait=uninstrumented fun:epoll_wait=uninstrumented fun:erand48=uninstrumented fun:erand48_r=uninstrumented fun:erf=uninstrumented fun:erfc=uninstrumented fun:erfcf=uninstrumented fun:erfcl=uninstrumented fun:erff=uninstrumented fun:erfl=uninstrumented fun:err=uninstrumented fun:error=uninstrumented fun:error_at_line=uninstrumented fun:errx=uninstrumented fun:ether_aton=uninstrumented fun:ether_aton_r=uninstrumented fun:ether_hostton=uninstrumented fun:ether_line=uninstrumented fun:ether_ntoa=uninstrumented fun:ether_ntoa_r=uninstrumented fun:ether_ntohost=uninstrumented fun:euidaccess=uninstrumented fun:eventfd=uninstrumented fun:eventfd_read=uninstrumented fun:eventfd_write=uninstrumented fun:execl=uninstrumented fun:execle=uninstrumented fun:execlp=uninstrumented fun:execv=uninstrumented fun:execve=uninstrumented fun:execvp=uninstrumented fun:execvpe=uninstrumented fun:exit=uninstrumented fun:exp=uninstrumented fun:exp10=uninstrumented fun:exp10f=uninstrumented fun:exp10l=uninstrumented fun:exp2=uninstrumented fun:exp2f=uninstrumented fun:exp2l=uninstrumented fun:expf=uninstrumented fun:expl=uninstrumented fun:expm1=uninstrumented fun:expm1f=uninstrumented fun:expm1l=uninstrumented fun:fabs=uninstrumented fun:fabsf=uninstrumented fun:fabsl=uninstrumented fun:faccessat=uninstrumented fun:fallocate=uninstrumented fun:fallocate64=uninstrumented fun:fanotify_init=uninstrumented fun:fanotify_mark=uninstrumented fun:fattach=uninstrumented fun:fchdir=uninstrumented fun:fchflags=uninstrumented fun:fchmod=uninstrumented fun:fchmodat=uninstrumented fun:fchown=uninstrumented fun:fchownat=uninstrumented fun:fclose=uninstrumented fun:fcloseall=uninstrumented fun:fcntl=uninstrumented fun:fcrypt=uninstrumented fun:fcvt=uninstrumented fun:fcvt_r=uninstrumented fun:fdatasync=uninstrumented fun:fdetach=uninstrumented fun:fdim=uninstrumented fun:fdimf=uninstrumented fun:fdiml=uninstrumented fun:fdopen=uninstrumented fun:fdopendir=uninstrumented fun:feclearexcept=uninstrumented fun:fedisableexcept=uninstrumented fun:feenableexcept=uninstrumented fun:fegetenv=uninstrumented fun:fegetexcept=uninstrumented fun:fegetexceptflag=uninstrumented fun:fegetround=uninstrumented fun:feholdexcept=uninstrumented fun:feof=uninstrumented fun:feof_unlocked=uninstrumented fun:feraiseexcept=uninstrumented fun:ferror=uninstrumented fun:ferror_unlocked=uninstrumented fun:fesetenv=uninstrumented fun:fesetexceptflag=uninstrumented fun:fesetround=uninstrumented fun:fetestexcept=uninstrumented fun:feupdateenv=uninstrumented fun:fexecve=uninstrumented fun:fflush=uninstrumented fun:fflush_unlocked=uninstrumented fun:ffs=uninstrumented fun:ffsl=uninstrumented fun:ffsll=uninstrumented fun:fgetc=uninstrumented fun:fgetc_unlocked=uninstrumented fun:fgetgrent=uninstrumented fun:fgetgrent_r=uninstrumented fun:fgetpos=uninstrumented fun:fgetpos64=uninstrumented fun:fgetpwent=uninstrumented fun:fgetpwent_r=uninstrumented fun:fgets=uninstrumented fun:fgets_unlocked=uninstrumented fun:fgetsgent=uninstrumented fun:fgetsgent_r=uninstrumented fun:fgetspent=uninstrumented fun:fgetspent_r=uninstrumented fun:fgetwc=uninstrumented fun:fgetwc_unlocked=uninstrumented fun:fgetws=uninstrumented fun:fgetws_unlocked=uninstrumented fun:fgetxattr=uninstrumented fun:fileno=uninstrumented fun:fileno_unlocked=uninstrumented fun:finite=uninstrumented fun:finitef=uninstrumented fun:finitel=uninstrumented fun:flistxattr=uninstrumented fun:flock=uninstrumented fun:flockfile=uninstrumented fun:floor=uninstrumented fun:floorf=uninstrumented fun:floorl=uninstrumented fun:fma=uninstrumented fun:fmaf=uninstrumented fun:fmal=uninstrumented fun:fmax=uninstrumented fun:fmaxf=uninstrumented fun:fmaxl=uninstrumented fun:fmemopen=uninstrumented fun:fmin=uninstrumented fun:fminf=uninstrumented fun:fminl=uninstrumented fun:fmod=uninstrumented fun:fmodf=uninstrumented fun:fmodl=uninstrumented fun:fmtmsg=uninstrumented fun:fnmatch=uninstrumented fun:fopen=uninstrumented fun:fopen64=uninstrumented fun:fopencookie=uninstrumented fun:fork=uninstrumented fun:forkpty=uninstrumented fun:fpathconf=uninstrumented fun:fprintf=uninstrumented fun:fputc=uninstrumented fun:fputc_unlocked=uninstrumented fun:fputs=uninstrumented fun:fputs_unlocked=uninstrumented fun:fputwc=uninstrumented fun:fputwc_unlocked=uninstrumented fun:fputws=uninstrumented fun:fputws_unlocked=uninstrumented fun:fread=uninstrumented fun:fread_unlocked=uninstrumented fun:free=uninstrumented fun:freeaddrinfo=uninstrumented fun:freeifaddrs=uninstrumented fun:freelocale=uninstrumented fun:fremovexattr=uninstrumented fun:freopen=uninstrumented fun:freopen64=uninstrumented fun:frexp=uninstrumented fun:frexpf=uninstrumented fun:frexpl=uninstrumented fun:fscanf=uninstrumented fun:fseek=uninstrumented fun:fseeko=uninstrumented fun:fseeko64=uninstrumented fun:fsetpos=uninstrumented fun:fsetpos64=uninstrumented fun:fsetxattr=uninstrumented fun:fstat=uninstrumented fun:fstat64=uninstrumented fun:fstatat=uninstrumented fun:fstatat64=uninstrumented fun:fstatfs=uninstrumented fun:fstatfs64=uninstrumented fun:fstatvfs=uninstrumented fun:fstatvfs64=uninstrumented fun:fsync=uninstrumented fun:ftell=uninstrumented fun:ftello=uninstrumented fun:ftello64=uninstrumented fun:ftime=uninstrumented fun:ftok=uninstrumented fun:ftruncate=uninstrumented fun:ftruncate64=uninstrumented fun:ftrylockfile=uninstrumented fun:fts_children=uninstrumented fun:fts_close=uninstrumented fun:fts_open=uninstrumented fun:fts_read=uninstrumented fun:fts_set=uninstrumented fun:ftw=uninstrumented fun:ftw64=uninstrumented fun:funlockfile=uninstrumented fun:futimens=uninstrumented fun:futimes=uninstrumented fun:futimesat=uninstrumented fun:fwide=uninstrumented fun:fwprintf=uninstrumented fun:fwrite=uninstrumented fun:fwrite_unlocked=uninstrumented fun:fwscanf=uninstrumented fun:gai_cancel=uninstrumented fun:gai_error=uninstrumented fun:gai_strerror=uninstrumented fun:gai_suspend=uninstrumented fun:gamma=uninstrumented fun:gammaf=uninstrumented fun:gammal=uninstrumented fun:gcvt=uninstrumented fun:get_avphys_pages=uninstrumented fun:get_current_dir_name=uninstrumented fun:get_kernel_syms=uninstrumented fun:get_myaddress=uninstrumented fun:get_nprocs=uninstrumented fun:get_nprocs_conf=uninstrumented fun:get_phys_pages=uninstrumented fun:getaddrinfo=uninstrumented fun:getaddrinfo_a=uninstrumented fun:getaliasbyname=uninstrumented fun:getaliasbyname_r=uninstrumented fun:getaliasent=uninstrumented fun:getaliasent_r=uninstrumented fun:getauxval=uninstrumented fun:getc=uninstrumented fun:getc_unlocked=uninstrumented fun:getchar=uninstrumented fun:getchar_unlocked=uninstrumented fun:getcontext=uninstrumented fun:getcwd=uninstrumented fun:getdate=uninstrumented fun:getdate_r=uninstrumented fun:getdelim=uninstrumented fun:getdirentries=uninstrumented fun:getdirentries64=uninstrumented fun:getdomainname=uninstrumented fun:getdtablesize=uninstrumented fun:getegid=uninstrumented fun:getenv=uninstrumented fun:geteuid=uninstrumented fun:getfsent=uninstrumented fun:getfsfile=uninstrumented fun:getfsspec=uninstrumented fun:getgid=uninstrumented fun:getgrent=uninstrumented fun:getgrent_r=uninstrumented fun:getgrgid=uninstrumented fun:getgrgid_r=uninstrumented fun:getgrnam=uninstrumented fun:getgrnam_r=uninstrumented fun:getgrouplist=uninstrumented fun:getgroups=uninstrumented fun:gethostbyaddr=uninstrumented fun:gethostbyaddr_r=uninstrumented fun:gethostbyname=uninstrumented fun:gethostbyname2=uninstrumented fun:gethostbyname2_r=uninstrumented fun:gethostbyname_r=uninstrumented fun:gethostent=uninstrumented fun:gethostent_r=uninstrumented fun:gethostid=uninstrumented fun:gethostname=uninstrumented fun:getifaddrs=uninstrumented fun:getipv4sourcefilter=uninstrumented fun:getitimer=uninstrumented fun:getline=uninstrumented fun:getloadavg=uninstrumented fun:getlogin=uninstrumented fun:getlogin_r=uninstrumented fun:getmntent=uninstrumented fun:getmntent_r=uninstrumented fun:getmsg=uninstrumented fun:getnameinfo=uninstrumented fun:getnetbyaddr=uninstrumented fun:getnetbyaddr_r=uninstrumented fun:getnetbyname=uninstrumented fun:getnetbyname_r=uninstrumented fun:getnetent=uninstrumented fun:getnetent_r=uninstrumented fun:getnetgrent=uninstrumented fun:getnetgrent_r=uninstrumented fun:getnetname=uninstrumented fun:getopt=uninstrumented fun:getopt_long=uninstrumented fun:getopt_long_only=uninstrumented fun:getpagesize=uninstrumented fun:getpass=uninstrumented fun:getpeername=uninstrumented fun:getpgid=uninstrumented fun:getpgrp=uninstrumented fun:getpid=uninstrumented fun:getpmsg=uninstrumented fun:getppid=uninstrumented fun:getpriority=uninstrumented fun:getprotobyname=uninstrumented fun:getprotobyname_r=uninstrumented fun:getprotobynumber=uninstrumented fun:getprotobynumber_r=uninstrumented fun:getprotoent=uninstrumented fun:getprotoent_r=uninstrumented fun:getpt=uninstrumented fun:getpublickey=uninstrumented fun:getpw=uninstrumented fun:getpwent=uninstrumented fun:getpwent_r=uninstrumented fun:getpwnam=uninstrumented fun:getpwnam_r=uninstrumented fun:getpwuid=uninstrumented fun:getpwuid_r=uninstrumented fun:getresgid=uninstrumented fun:getresuid=uninstrumented fun:getrlimit=uninstrumented fun:getrlimit64=uninstrumented fun:getrpcbyname=uninstrumented fun:getrpcbyname_r=uninstrumented fun:getrpcbynumber=uninstrumented fun:getrpcbynumber_r=uninstrumented fun:getrpcent=uninstrumented fun:getrpcent_r=uninstrumented fun:getrpcport=uninstrumented fun:getrusage=uninstrumented fun:gets=uninstrumented fun:getsecretkey=uninstrumented fun:getservbyname=uninstrumented fun:getservbyname_r=uninstrumented fun:getservbyport=uninstrumented fun:getservbyport_r=uninstrumented fun:getservent=uninstrumented fun:getservent_r=uninstrumented fun:getsgent=uninstrumented fun:getsgent_r=uninstrumented fun:getsgnam=uninstrumented fun:getsgnam_r=uninstrumented fun:getsid=uninstrumented fun:getsockname=uninstrumented fun:getsockopt=uninstrumented fun:getsourcefilter=uninstrumented fun:getspent=uninstrumented fun:getspent_r=uninstrumented fun:getspnam=uninstrumented fun:getspnam_r=uninstrumented fun:getsubopt=uninstrumented fun:gettext=uninstrumented fun:gettimeofday=uninstrumented fun:getttyent=uninstrumented fun:getttynam=uninstrumented fun:getuid=uninstrumented fun:getusershell=uninstrumented fun:getutent=uninstrumented fun:getutent_r=uninstrumented fun:getutid=uninstrumented fun:getutid_r=uninstrumented fun:getutline=uninstrumented fun:getutline_r=uninstrumented fun:getutmp=uninstrumented fun:getutmpx=uninstrumented fun:getutxent=uninstrumented fun:getutxid=uninstrumented fun:getutxline=uninstrumented fun:getw=uninstrumented fun:getwc=uninstrumented fun:getwc_unlocked=uninstrumented fun:getwchar=uninstrumented fun:getwchar_unlocked=uninstrumented fun:getwd=uninstrumented fun:getxattr=uninstrumented fun:glob=uninstrumented fun:glob64=uninstrumented fun:glob_pattern_p=uninstrumented fun:globfree=uninstrumented fun:globfree64=uninstrumented fun:gmtime=uninstrumented fun:gmtime_r=uninstrumented fun:gnu_dev_major=uninstrumented fun:gnu_dev_makedev=uninstrumented fun:gnu_dev_minor=uninstrumented fun:gnu_get_libc_release=uninstrumented fun:gnu_get_libc_version=uninstrumented fun:grantpt=uninstrumented fun:group_member=uninstrumented fun:gsignal=uninstrumented fun:gtty=uninstrumented fun:hasmntopt=uninstrumented fun:hcreate=uninstrumented fun:hcreate_r=uninstrumented fun:hdestroy=uninstrumented fun:hdestroy_r=uninstrumented fun:herror=uninstrumented fun:host2netname=uninstrumented fun:hsearch=uninstrumented fun:hsearch_r=uninstrumented fun:hstrerror=uninstrumented fun:htonl=uninstrumented fun:htons=uninstrumented fun:hypot=uninstrumented fun:hypotf=uninstrumented fun:hypotl=uninstrumented fun:iconv=uninstrumented fun:iconv_close=uninstrumented fun:iconv_open=uninstrumented fun:idna_to_ascii_lz=uninstrumented fun:idna_to_unicode_lzlz=uninstrumented fun:if_freenameindex=uninstrumented fun:if_indextoname=uninstrumented fun:if_nameindex=uninstrumented fun:if_nametoindex=uninstrumented fun:ilogb=uninstrumented fun:ilogbf=uninstrumented fun:ilogbl=uninstrumented fun:imaxabs=uninstrumented fun:imaxdiv=uninstrumented fun:index=uninstrumented fun:inet6_opt_append=uninstrumented fun:inet6_opt_find=uninstrumented fun:inet6_opt_finish=uninstrumented fun:inet6_opt_get_val=uninstrumented fun:inet6_opt_init=uninstrumented fun:inet6_opt_next=uninstrumented fun:inet6_opt_set_val=uninstrumented fun:inet6_option_alloc=uninstrumented fun:inet6_option_append=uninstrumented fun:inet6_option_find=uninstrumented fun:inet6_option_init=uninstrumented fun:inet6_option_next=uninstrumented fun:inet6_option_space=uninstrumented fun:inet6_rth_add=uninstrumented fun:inet6_rth_getaddr=uninstrumented fun:inet6_rth_init=uninstrumented fun:inet6_rth_reverse=uninstrumented fun:inet6_rth_segments=uninstrumented fun:inet6_rth_space=uninstrumented fun:inet_addr=uninstrumented fun:inet_aton=uninstrumented fun:inet_lnaof=uninstrumented fun:inet_makeaddr=uninstrumented fun:inet_net_ntop=uninstrumented fun:inet_net_pton=uninstrumented fun:inet_neta=uninstrumented fun:inet_netof=uninstrumented fun:inet_network=uninstrumented fun:inet_nsap_addr=uninstrumented fun:inet_nsap_ntoa=uninstrumented fun:inet_ntoa=uninstrumented fun:inet_ntop=uninstrumented fun:inet_pton=uninstrumented fun:init_module=uninstrumented fun:initgroups=uninstrumented fun:initstate=uninstrumented fun:initstate_r=uninstrumented fun:innetgr=uninstrumented fun:inotify_add_watch=uninstrumented fun:inotify_init=uninstrumented fun:inotify_init1=uninstrumented fun:inotify_rm_watch=uninstrumented fun:insque=uninstrumented fun:ioctl=uninstrumented fun:ioperm=uninstrumented fun:iopl=uninstrumented fun:iruserok=uninstrumented fun:iruserok_af=uninstrumented fun:isalnum=uninstrumented fun:isalnum_l=uninstrumented fun:isalpha=uninstrumented fun:isalpha_l=uninstrumented fun:isascii=uninstrumented fun:isastream=uninstrumented fun:isatty=uninstrumented fun:isblank=uninstrumented fun:isblank_l=uninstrumented fun:iscntrl=uninstrumented fun:iscntrl_l=uninstrumented fun:isctype=uninstrumented fun:isdigit=uninstrumented fun:isdigit_l=uninstrumented fun:isfdtype=uninstrumented fun:isgraph=uninstrumented fun:isgraph_l=uninstrumented fun:isinf=uninstrumented fun:isinfd128=uninstrumented fun:isinfd32=uninstrumented fun:isinfd64=uninstrumented fun:isinff=uninstrumented fun:isinfl=uninstrumented fun:islower=uninstrumented fun:islower_l=uninstrumented fun:isnan=uninstrumented fun:isnanf=uninstrumented fun:isnanl=uninstrumented fun:isprint=uninstrumented fun:isprint_l=uninstrumented fun:ispunct=uninstrumented fun:ispunct_l=uninstrumented fun:isspace=uninstrumented fun:isspace_l=uninstrumented fun:isupper=uninstrumented fun:isupper_l=uninstrumented fun:iswalnum=uninstrumented fun:iswalnum_l=uninstrumented fun:iswalpha=uninstrumented fun:iswalpha_l=uninstrumented fun:iswblank=uninstrumented fun:iswblank_l=uninstrumented fun:iswcntrl=uninstrumented fun:iswcntrl_l=uninstrumented fun:iswctype=uninstrumented fun:iswctype_l=uninstrumented fun:iswdigit=uninstrumented fun:iswdigit_l=uninstrumented fun:iswgraph=uninstrumented fun:iswgraph_l=uninstrumented fun:iswlower=uninstrumented fun:iswlower_l=uninstrumented fun:iswprint=uninstrumented fun:iswprint_l=uninstrumented fun:iswpunct=uninstrumented fun:iswpunct_l=uninstrumented fun:iswspace=uninstrumented fun:iswspace_l=uninstrumented fun:iswupper=uninstrumented fun:iswupper_l=uninstrumented fun:iswxdigit=uninstrumented fun:iswxdigit_l=uninstrumented fun:isxdigit=uninstrumented fun:isxdigit_l=uninstrumented fun:j0=uninstrumented fun:j0f=uninstrumented fun:j0l=uninstrumented fun:j1=uninstrumented fun:j1f=uninstrumented fun:j1l=uninstrumented fun:jn=uninstrumented fun:jnf=uninstrumented fun:jnl=uninstrumented fun:jrand48=uninstrumented fun:jrand48_r=uninstrumented fun:key_decryptsession=uninstrumented fun:key_decryptsession_pk=uninstrumented fun:key_encryptsession=uninstrumented fun:key_encryptsession_pk=uninstrumented fun:key_gendes=uninstrumented fun:key_get_conv=uninstrumented fun:key_secretkey_is_set=uninstrumented fun:key_setnet=uninstrumented fun:key_setsecret=uninstrumented fun:kill=uninstrumented fun:killpg=uninstrumented fun:klogctl=uninstrumented fun:l64a=uninstrumented fun:labs=uninstrumented fun:lchmod=uninstrumented fun:lchown=uninstrumented fun:lckpwdf=uninstrumented fun:lcong48=uninstrumented fun:lcong48_r=uninstrumented fun:ldexp=uninstrumented fun:ldexpf=uninstrumented fun:ldexpl=uninstrumented fun:ldiv=uninstrumented fun:lfind=uninstrumented fun:lgamma=uninstrumented fun:lgamma_r=uninstrumented fun:lgammaf=uninstrumented fun:lgammaf_r=uninstrumented fun:lgammal=uninstrumented fun:lgammal_r=uninstrumented fun:lgetxattr=uninstrumented fun:link=uninstrumented fun:linkat=uninstrumented fun:lio_listio=uninstrumented fun:lio_listio64=uninstrumented fun:listen=uninstrumented fun:listxattr=uninstrumented fun:llabs=uninstrumented fun:lldiv=uninstrumented fun:llistxattr=uninstrumented fun:llrint=uninstrumented fun:llrintf=uninstrumented fun:llrintl=uninstrumented fun:llround=uninstrumented fun:llroundf=uninstrumented fun:llroundl=uninstrumented fun:llseek=uninstrumented fun:localeconv=uninstrumented fun:localtime=uninstrumented fun:localtime_r=uninstrumented fun:lockf=uninstrumented fun:lockf64=uninstrumented fun:log=uninstrumented fun:log10=uninstrumented fun:log10f=uninstrumented fun:log10l=uninstrumented fun:log1p=uninstrumented fun:log1pf=uninstrumented fun:log1pl=uninstrumented fun:log2=uninstrumented fun:log2f=uninstrumented fun:log2l=uninstrumented fun:logb=uninstrumented fun:logbf=uninstrumented fun:logbl=uninstrumented fun:logf=uninstrumented fun:login=uninstrumented fun:login_tty=uninstrumented fun:logl=uninstrumented fun:logout=uninstrumented fun:logwtmp=uninstrumented fun:longjmp=uninstrumented fun:lrand48=uninstrumented fun:lrand48_r=uninstrumented fun:lremovexattr=uninstrumented fun:lrint=uninstrumented fun:lrintf=uninstrumented fun:lrintl=uninstrumented fun:lround=uninstrumented fun:lroundf=uninstrumented fun:lroundl=uninstrumented fun:lsearch=uninstrumented fun:lseek=uninstrumented fun:lseek64=uninstrumented fun:lsetxattr=uninstrumented fun:lstat=uninstrumented fun:lstat64=uninstrumented fun:lutimes=uninstrumented fun:madvise=uninstrumented fun:makecontext=uninstrumented fun:mallinfo=uninstrumented fun:malloc=uninstrumented fun:malloc_get_state=uninstrumented fun:malloc_info=uninstrumented fun:malloc_set_state=uninstrumented fun:malloc_stats=uninstrumented fun:malloc_trim=uninstrumented fun:malloc_usable_size=uninstrumented fun:mallopt=uninstrumented fun:matherr=uninstrumented fun:mblen=uninstrumented fun:mbrlen=uninstrumented fun:mbrtoc16=uninstrumented fun:mbrtoc32=uninstrumented fun:mbrtowc=uninstrumented fun:mbsinit=uninstrumented fun:mbsnrtowcs=uninstrumented fun:mbsrtowcs=uninstrumented fun:mbstowcs=uninstrumented fun:mbtowc=uninstrumented fun:mcheck=uninstrumented fun:mcheck_check_all=uninstrumented fun:mcheck_pedantic=uninstrumented fun:mcount=uninstrumented fun:memalign=uninstrumented fun:memccpy=uninstrumented fun:memchr=uninstrumented fun:memcmp=uninstrumented fun:memcpy=uninstrumented fun:memfrob=uninstrumented fun:memmem=uninstrumented fun:memmove=uninstrumented fun:mempcpy=uninstrumented fun:memrchr=uninstrumented fun:memset=uninstrumented fun:mincore=uninstrumented fun:mkdir=uninstrumented fun:mkdirat=uninstrumented fun:mkdtemp=uninstrumented fun:mkfifo=uninstrumented fun:mkfifoat=uninstrumented fun:mknod=uninstrumented fun:mknodat=uninstrumented fun:mkostemp=uninstrumented fun:mkostemp64=uninstrumented fun:mkostemps=uninstrumented fun:mkostemps64=uninstrumented fun:mkstemp=uninstrumented fun:mkstemp64=uninstrumented fun:mkstemps=uninstrumented fun:mkstemps64=uninstrumented fun:mktemp=uninstrumented fun:mktime=uninstrumented fun:mlock=uninstrumented fun:mlockall=uninstrumented fun:mmap=uninstrumented fun:mmap64=uninstrumented fun:modf=uninstrumented fun:modff=uninstrumented fun:modfl=uninstrumented fun:modify_ldt=uninstrumented fun:moncontrol=uninstrumented fun:monstartup=uninstrumented fun:mount=uninstrumented fun:mprobe=uninstrumented fun:mprotect=uninstrumented fun:mq_close=uninstrumented fun:mq_getattr=uninstrumented fun:mq_notify=uninstrumented fun:mq_open=uninstrumented fun:mq_receive=uninstrumented fun:mq_send=uninstrumented fun:mq_setattr=uninstrumented fun:mq_timedreceive=uninstrumented fun:mq_timedsend=uninstrumented fun:mq_unlink=uninstrumented fun:mrand48=uninstrumented fun:mrand48_r=uninstrumented fun:mremap=uninstrumented fun:msgctl=uninstrumented fun:msgget=uninstrumented fun:msgrcv=uninstrumented fun:msgsnd=uninstrumented fun:msync=uninstrumented fun:mtrace=uninstrumented fun:munlock=uninstrumented fun:munlockall=uninstrumented fun:munmap=uninstrumented fun:muntrace=uninstrumented fun:name_to_handle_at=uninstrumented fun:nan=uninstrumented fun:nanf=uninstrumented fun:nanl=uninstrumented fun:nanosleep=uninstrumented fun:nearbyint=uninstrumented fun:nearbyintf=uninstrumented fun:nearbyintl=uninstrumented fun:netname2host=uninstrumented fun:netname2user=uninstrumented fun:newlocale=uninstrumented fun:nextafter=uninstrumented fun:nextafterf=uninstrumented fun:nextafterl=uninstrumented fun:nexttoward=uninstrumented fun:nexttowardf=uninstrumented fun:nexttowardl=uninstrumented fun:nfsservctl=uninstrumented fun:nftw=uninstrumented fun:nftw64=uninstrumented fun:ngettext=uninstrumented fun:nice=uninstrumented fun:nis_add=uninstrumented fun:nis_add_entry=uninstrumented fun:nis_addmember=uninstrumented fun:nis_checkpoint=uninstrumented fun:nis_clone_directory=uninstrumented fun:nis_clone_object=uninstrumented fun:nis_clone_result=uninstrumented fun:nis_creategroup=uninstrumented fun:nis_destroy_object=uninstrumented fun:nis_destroygroup=uninstrumented fun:nis_dir_cmp=uninstrumented fun:nis_domain_of=uninstrumented fun:nis_domain_of_r=uninstrumented fun:nis_first_entry=uninstrumented fun:nis_free_directory=uninstrumented fun:nis_free_object=uninstrumented fun:nis_free_request=uninstrumented fun:nis_freenames=uninstrumented fun:nis_freeresult=uninstrumented fun:nis_freeservlist=uninstrumented fun:nis_freetags=uninstrumented fun:nis_getnames=uninstrumented fun:nis_getservlist=uninstrumented fun:nis_ismember=uninstrumented fun:nis_leaf_of=uninstrumented fun:nis_leaf_of_r=uninstrumented fun:nis_lerror=uninstrumented fun:nis_list=uninstrumented fun:nis_local_directory=uninstrumented fun:nis_local_group=uninstrumented fun:nis_local_host=uninstrumented fun:nis_local_principal=uninstrumented fun:nis_lookup=uninstrumented fun:nis_mkdir=uninstrumented fun:nis_modify=uninstrumented fun:nis_modify_entry=uninstrumented fun:nis_name_of=uninstrumented fun:nis_name_of_r=uninstrumented fun:nis_next_entry=uninstrumented fun:nis_perror=uninstrumented fun:nis_ping=uninstrumented fun:nis_print_directory=uninstrumented fun:nis_print_entry=uninstrumented fun:nis_print_group=uninstrumented fun:nis_print_group_entry=uninstrumented fun:nis_print_link=uninstrumented fun:nis_print_object=uninstrumented fun:nis_print_result=uninstrumented fun:nis_print_rights=uninstrumented fun:nis_print_table=uninstrumented fun:nis_read_obj=uninstrumented fun:nis_remove=uninstrumented fun:nis_remove_entry=uninstrumented fun:nis_removemember=uninstrumented fun:nis_rmdir=uninstrumented fun:nis_servstate=uninstrumented fun:nis_sperrno=uninstrumented fun:nis_sperror=uninstrumented fun:nis_sperror_r=uninstrumented fun:nis_stats=uninstrumented fun:nis_verifygroup=uninstrumented fun:nis_write_obj=uninstrumented fun:nl_langinfo=uninstrumented fun:nl_langinfo_l=uninstrumented fun:nrand48=uninstrumented fun:nrand48_r=uninstrumented fun:ns_datetosecs=uninstrumented fun:ns_format_ttl=uninstrumented fun:ns_get16=uninstrumented fun:ns_get32=uninstrumented fun:ns_initparse=uninstrumented fun:ns_makecanon=uninstrumented fun:ns_msg_getflag=uninstrumented fun:ns_name_compress=uninstrumented fun:ns_name_ntol=uninstrumented fun:ns_name_ntop=uninstrumented fun:ns_name_pack=uninstrumented fun:ns_name_pton=uninstrumented fun:ns_name_rollback=uninstrumented fun:ns_name_skip=uninstrumented fun:ns_name_uncompress=uninstrumented fun:ns_name_unpack=uninstrumented fun:ns_parse_ttl=uninstrumented fun:ns_parserr=uninstrumented fun:ns_put16=uninstrumented fun:ns_put32=uninstrumented fun:ns_samedomain=uninstrumented fun:ns_samename=uninstrumented fun:ns_skiprr=uninstrumented fun:ns_sprintrr=uninstrumented fun:ns_sprintrrf=uninstrumented fun:ns_subdomain=uninstrumented fun:ntohl=uninstrumented fun:ntohs=uninstrumented fun:ntp_adjtime=uninstrumented fun:ntp_gettime=uninstrumented fun:ntp_gettimex=uninstrumented fun:obstack_free=uninstrumented fun:obstack_printf=uninstrumented fun:obstack_vprintf=uninstrumented fun:on_exit=uninstrumented fun:open=uninstrumented fun:open64=uninstrumented fun:open_by_handle_at=uninstrumented fun:open_memstream=uninstrumented fun:open_wmemstream=uninstrumented fun:openat=uninstrumented fun:openat64=uninstrumented fun:opendir=uninstrumented fun:openlog=uninstrumented fun:openpty=uninstrumented fun:parse_printf_format=uninstrumented fun:passwd2des=uninstrumented fun:pathconf=uninstrumented fun:pause=uninstrumented fun:pclose=uninstrumented fun:perror=uninstrumented fun:personality=uninstrumented fun:pipe=uninstrumented fun:pipe2=uninstrumented fun:pivot_root=uninstrumented fun:pmap_getmaps=uninstrumented fun:pmap_getport=uninstrumented fun:pmap_rmtcall=uninstrumented fun:pmap_set=uninstrumented fun:pmap_unset=uninstrumented fun:poll=uninstrumented fun:popen=uninstrumented fun:posix_fadvise=uninstrumented fun:posix_fadvise64=uninstrumented fun:posix_fallocate=uninstrumented fun:posix_fallocate64=uninstrumented fun:posix_madvise=uninstrumented fun:posix_memalign=uninstrumented fun:posix_openpt=uninstrumented fun:posix_spawn=uninstrumented fun:posix_spawn_file_actions_addclose=uninstrumented fun:posix_spawn_file_actions_adddup2=uninstrumented fun:posix_spawn_file_actions_addopen=uninstrumented fun:posix_spawn_file_actions_destroy=uninstrumented fun:posix_spawn_file_actions_init=uninstrumented fun:posix_spawnattr_destroy=uninstrumented fun:posix_spawnattr_getflags=uninstrumented fun:posix_spawnattr_getpgroup=uninstrumented fun:posix_spawnattr_getschedparam=uninstrumented fun:posix_spawnattr_getschedpolicy=uninstrumented fun:posix_spawnattr_getsigdefault=uninstrumented fun:posix_spawnattr_getsigmask=uninstrumented fun:posix_spawnattr_init=uninstrumented fun:posix_spawnattr_setflags=uninstrumented fun:posix_spawnattr_setpgroup=uninstrumented fun:posix_spawnattr_setschedparam=uninstrumented fun:posix_spawnattr_setschedpolicy=uninstrumented fun:posix_spawnattr_setsigdefault=uninstrumented fun:posix_spawnattr_setsigmask=uninstrumented fun:posix_spawnp=uninstrumented fun:pow=uninstrumented fun:pow10=uninstrumented fun:pow10f=uninstrumented fun:pow10l=uninstrumented fun:powf=uninstrumented fun:powl=uninstrumented fun:ppoll=uninstrumented fun:prctl=uninstrumented fun:pread=uninstrumented fun:pread64=uninstrumented fun:preadv=uninstrumented fun:preadv64=uninstrumented fun:printf=uninstrumented fun:printf_size=uninstrumented fun:printf_size_info=uninstrumented fun:prlimit=uninstrumented fun:prlimit64=uninstrumented fun:process_vm_readv=uninstrumented fun:process_vm_writev=uninstrumented fun:profil=uninstrumented fun:pselect=uninstrumented fun:psiginfo=uninstrumented fun:psignal=uninstrumented fun:pthread_atfork=uninstrumented fun:pthread_attr_destroy=uninstrumented fun:pthread_attr_getaffinity_np=uninstrumented fun:pthread_attr_getdetachstate=uninstrumented fun:pthread_attr_getguardsize=uninstrumented fun:pthread_attr_getinheritsched=uninstrumented fun:pthread_attr_getschedparam=uninstrumented fun:pthread_attr_getschedpolicy=uninstrumented fun:pthread_attr_getscope=uninstrumented fun:pthread_attr_getstack=uninstrumented fun:pthread_attr_getstackaddr=uninstrumented fun:pthread_attr_getstacksize=uninstrumented fun:pthread_attr_init=uninstrumented fun:pthread_attr_setaffinity_np=uninstrumented fun:pthread_attr_setdetachstate=uninstrumented fun:pthread_attr_setguardsize=uninstrumented fun:pthread_attr_setinheritsched=uninstrumented fun:pthread_attr_setschedparam=uninstrumented fun:pthread_attr_setschedpolicy=uninstrumented fun:pthread_attr_setscope=uninstrumented fun:pthread_attr_setstack=uninstrumented fun:pthread_attr_setstackaddr=uninstrumented fun:pthread_attr_setstacksize=uninstrumented fun:pthread_barrier_destroy=uninstrumented fun:pthread_barrier_init=uninstrumented fun:pthread_barrier_wait=uninstrumented fun:pthread_barrierattr_destroy=uninstrumented fun:pthread_barrierattr_getpshared=uninstrumented fun:pthread_barrierattr_init=uninstrumented fun:pthread_barrierattr_setpshared=uninstrumented fun:pthread_cancel=uninstrumented fun:pthread_cond_broadcast=uninstrumented fun:pthread_cond_destroy=uninstrumented fun:pthread_cond_init=uninstrumented fun:pthread_cond_signal=uninstrumented fun:pthread_cond_timedwait=uninstrumented fun:pthread_cond_wait=uninstrumented fun:pthread_condattr_destroy=uninstrumented fun:pthread_condattr_getclock=uninstrumented fun:pthread_condattr_getpshared=uninstrumented fun:pthread_condattr_init=uninstrumented fun:pthread_condattr_setclock=uninstrumented fun:pthread_condattr_setpshared=uninstrumented fun:pthread_create=uninstrumented fun:pthread_detach=uninstrumented fun:pthread_equal=uninstrumented fun:pthread_exit=uninstrumented fun:pthread_getaffinity_np=uninstrumented fun:pthread_getattr_default_np=uninstrumented fun:pthread_getattr_np=uninstrumented fun:pthread_getconcurrency=uninstrumented fun:pthread_getcpuclockid=uninstrumented fun:pthread_getname_np=uninstrumented fun:pthread_getschedparam=uninstrumented fun:pthread_getspecific=uninstrumented fun:pthread_join=uninstrumented fun:pthread_key_create=uninstrumented fun:pthread_key_delete=uninstrumented fun:pthread_kill=uninstrumented fun:pthread_kill_other_threads_np=uninstrumented fun:pthread_mutex_consistent=uninstrumented fun:pthread_mutex_consistent_np=uninstrumented fun:pthread_mutex_destroy=uninstrumented fun:pthread_mutex_getprioceiling=uninstrumented fun:pthread_mutex_init=uninstrumented fun:pthread_mutex_lock=uninstrumented fun:pthread_mutex_setprioceiling=uninstrumented fun:pthread_mutex_timedlock=uninstrumented fun:pthread_mutex_trylock=uninstrumented fun:pthread_mutex_unlock=uninstrumented fun:pthread_mutexattr_destroy=uninstrumented fun:pthread_mutexattr_getkind_np=uninstrumented fun:pthread_mutexattr_getprioceiling=uninstrumented fun:pthread_mutexattr_getprotocol=uninstrumented fun:pthread_mutexattr_getpshared=uninstrumented fun:pthread_mutexattr_getrobust=uninstrumented fun:pthread_mutexattr_getrobust_np=uninstrumented fun:pthread_mutexattr_gettype=uninstrumented fun:pthread_mutexattr_init=uninstrumented fun:pthread_mutexattr_setkind_np=uninstrumented fun:pthread_mutexattr_setprioceiling=uninstrumented fun:pthread_mutexattr_setprotocol=uninstrumented fun:pthread_mutexattr_setpshared=uninstrumented fun:pthread_mutexattr_setrobust=uninstrumented fun:pthread_mutexattr_setrobust_np=uninstrumented fun:pthread_mutexattr_settype=uninstrumented fun:pthread_once=uninstrumented fun:pthread_rwlock_destroy=uninstrumented fun:pthread_rwlock_init=uninstrumented fun:pthread_rwlock_rdlock=uninstrumented fun:pthread_rwlock_timedrdlock=uninstrumented fun:pthread_rwlock_timedwrlock=uninstrumented fun:pthread_rwlock_tryrdlock=uninstrumented fun:pthread_rwlock_trywrlock=uninstrumented fun:pthread_rwlock_unlock=uninstrumented fun:pthread_rwlock_wrlock=uninstrumented fun:pthread_rwlockattr_destroy=uninstrumented fun:pthread_rwlockattr_getkind_np=uninstrumented fun:pthread_rwlockattr_getpshared=uninstrumented fun:pthread_rwlockattr_init=uninstrumented fun:pthread_rwlockattr_setkind_np=uninstrumented fun:pthread_rwlockattr_setpshared=uninstrumented fun:pthread_self=uninstrumented fun:pthread_setaffinity_np=uninstrumented fun:pthread_setattr_default_np=uninstrumented fun:pthread_setcancelstate=uninstrumented fun:pthread_setcanceltype=uninstrumented fun:pthread_setconcurrency=uninstrumented fun:pthread_setname_np=uninstrumented fun:pthread_setschedparam=uninstrumented fun:pthread_setschedprio=uninstrumented fun:pthread_setspecific=uninstrumented fun:pthread_sigmask=uninstrumented fun:pthread_sigqueue=uninstrumented fun:pthread_spin_destroy=uninstrumented fun:pthread_spin_init=uninstrumented fun:pthread_spin_lock=uninstrumented fun:pthread_spin_trylock=uninstrumented fun:pthread_spin_unlock=uninstrumented fun:pthread_testcancel=uninstrumented fun:pthread_timedjoin_np=uninstrumented fun:pthread_tryjoin_np=uninstrumented fun:pthread_yield=uninstrumented fun:ptrace=uninstrumented fun:ptsname=uninstrumented fun:ptsname_r=uninstrumented fun:putc=uninstrumented fun:putc_unlocked=uninstrumented fun:putchar=uninstrumented fun:putchar_unlocked=uninstrumented fun:putenv=uninstrumented fun:putgrent=uninstrumented fun:putmsg=uninstrumented fun:putpmsg=uninstrumented fun:putpwent=uninstrumented fun:puts=uninstrumented fun:putsgent=uninstrumented fun:putspent=uninstrumented fun:pututline=uninstrumented fun:pututxline=uninstrumented fun:putw=uninstrumented fun:putwc=uninstrumented fun:putwc_unlocked=uninstrumented fun:putwchar=uninstrumented fun:putwchar_unlocked=uninstrumented fun:pvalloc=uninstrumented fun:pwrite=uninstrumented fun:pwrite64=uninstrumented fun:pwritev=uninstrumented fun:pwritev64=uninstrumented fun:qecvt=uninstrumented fun:qecvt_r=uninstrumented fun:qfcvt=uninstrumented fun:qfcvt_r=uninstrumented fun:qgcvt=uninstrumented fun:qsort=uninstrumented fun:qsort_r=uninstrumented fun:query_module=uninstrumented fun:quick_exit=uninstrumented fun:quotactl=uninstrumented fun:raise=uninstrumented fun:rand=uninstrumented fun:rand_r=uninstrumented fun:random=uninstrumented fun:random_r=uninstrumented fun:rawmemchr=uninstrumented fun:rcmd=uninstrumented fun:rcmd_af=uninstrumented fun:re_comp=uninstrumented fun:re_compile_fastmap=uninstrumented fun:re_compile_pattern=uninstrumented fun:re_exec=uninstrumented fun:re_match=uninstrumented fun:re_match_2=uninstrumented fun:re_search=uninstrumented fun:re_search_2=uninstrumented fun:re_set_registers=uninstrumented fun:re_set_syntax=uninstrumented fun:read=uninstrumented fun:readColdStartFile=uninstrumented fun:readahead=uninstrumented fun:readdir=uninstrumented fun:readdir64=uninstrumented fun:readdir64_r=uninstrumented fun:readdir_r=uninstrumented fun:readlink=uninstrumented fun:readlinkat=uninstrumented fun:readv=uninstrumented fun:realloc=uninstrumented fun:realpath=uninstrumented fun:reboot=uninstrumented fun:recv=uninstrumented fun:recvfrom=uninstrumented fun:recvmmsg=uninstrumented fun:recvmsg=uninstrumented fun:regcomp=uninstrumented fun:regerror=uninstrumented fun:regexec=uninstrumented fun:regfree=uninstrumented fun:register_printf_function=uninstrumented fun:register_printf_modifier=uninstrumented fun:register_printf_specifier=uninstrumented fun:register_printf_type=uninstrumented fun:registerrpc=uninstrumented fun:remainder=uninstrumented fun:remainderf=uninstrumented fun:remainderl=uninstrumented fun:remap_file_pages=uninstrumented fun:remove=uninstrumented fun:removexattr=uninstrumented fun:remque=uninstrumented fun:remquo=uninstrumented fun:remquof=uninstrumented fun:remquol=uninstrumented fun:rename=uninstrumented fun:renameat=uninstrumented fun:res_gethostbyaddr=uninstrumented fun:res_gethostbyname=uninstrumented fun:res_gethostbyname2=uninstrumented fun:res_send_setqhook=uninstrumented fun:res_send_setrhook=uninstrumented fun:revoke=uninstrumented fun:rewind=uninstrumented fun:rewinddir=uninstrumented fun:rexec=uninstrumented fun:rexec_af=uninstrumented fun:rindex=uninstrumented fun:rint=uninstrumented fun:rintf=uninstrumented fun:rintl=uninstrumented fun:rmdir=uninstrumented fun:round=uninstrumented fun:roundf=uninstrumented fun:roundl=uninstrumented fun:rpmatch=uninstrumented fun:rresvport=uninstrumented fun:rresvport_af=uninstrumented fun:rtime=uninstrumented fun:ruserok=uninstrumented fun:ruserok_af=uninstrumented fun:ruserpass=uninstrumented fun:sbrk=uninstrumented fun:scalb=uninstrumented fun:scalbf=uninstrumented fun:scalbl=uninstrumented fun:scalbln=uninstrumented fun:scalblnf=uninstrumented fun:scalblnl=uninstrumented fun:scalbn=uninstrumented fun:scalbnf=uninstrumented fun:scalbnl=uninstrumented fun:scandir=uninstrumented fun:scandir64=uninstrumented fun:scandirat=uninstrumented fun:scandirat64=uninstrumented fun:scanf=uninstrumented fun:sched_get_priority_max=uninstrumented fun:sched_get_priority_min=uninstrumented fun:sched_getaffinity=uninstrumented fun:sched_getcpu=uninstrumented fun:sched_getparam=uninstrumented fun:sched_getscheduler=uninstrumented fun:sched_rr_get_interval=uninstrumented fun:sched_setaffinity=uninstrumented fun:sched_setparam=uninstrumented fun:sched_setscheduler=uninstrumented fun:sched_yield=uninstrumented fun:secure_getenv=uninstrumented fun:seed48=uninstrumented fun:seed48_r=uninstrumented fun:seekdir=uninstrumented fun:select=uninstrumented fun:sem_close=uninstrumented fun:sem_destroy=uninstrumented fun:sem_getvalue=uninstrumented fun:sem_init=uninstrumented fun:sem_open=uninstrumented fun:sem_post=uninstrumented fun:sem_timedwait=uninstrumented fun:sem_trywait=uninstrumented fun:sem_unlink=uninstrumented fun:sem_wait=uninstrumented fun:semctl=uninstrumented fun:semget=uninstrumented fun:semop=uninstrumented fun:semtimedop=uninstrumented fun:send=uninstrumented fun:sendfile=uninstrumented fun:sendfile64=uninstrumented fun:sendmmsg=uninstrumented fun:sendmsg=uninstrumented fun:sendto=uninstrumented fun:setaliasent=uninstrumented fun:setbuf=uninstrumented fun:setbuffer=uninstrumented fun:setcontext=uninstrumented fun:setdomainname=uninstrumented fun:setegid=uninstrumented fun:setenv=uninstrumented fun:seteuid=uninstrumented fun:setfsent=uninstrumented fun:setfsgid=uninstrumented fun:setfsuid=uninstrumented fun:setgid=uninstrumented fun:setgrent=uninstrumented fun:setgroups=uninstrumented fun:sethostent=uninstrumented fun:sethostid=uninstrumented fun:sethostname=uninstrumented fun:setipv4sourcefilter=uninstrumented fun:setitimer=uninstrumented fun:setjmp=uninstrumented fun:setkey=uninstrumented fun:setkey_r=uninstrumented fun:setlinebuf=uninstrumented fun:setlocale=uninstrumented fun:setlogin=uninstrumented fun:setlogmask=uninstrumented fun:setmntent=uninstrumented fun:setnetent=uninstrumented fun:setnetgrent=uninstrumented fun:setns=uninstrumented fun:setpgid=uninstrumented fun:setpgrp=uninstrumented fun:setpriority=uninstrumented fun:setprotoent=uninstrumented fun:setpwent=uninstrumented fun:setregid=uninstrumented fun:setresgid=uninstrumented fun:setresuid=uninstrumented fun:setreuid=uninstrumented fun:setrlimit=uninstrumented fun:setrlimit64=uninstrumented fun:setrpcent=uninstrumented fun:setservent=uninstrumented fun:setsgent=uninstrumented fun:setsid=uninstrumented fun:setsockopt=uninstrumented fun:setsourcefilter=uninstrumented fun:setspent=uninstrumented fun:setstate=uninstrumented fun:setstate_r=uninstrumented fun:settimeofday=uninstrumented fun:setttyent=uninstrumented fun:setuid=uninstrumented fun:setusershell=uninstrumented fun:setutent=uninstrumented fun:setutxent=uninstrumented fun:setvbuf=uninstrumented fun:setxattr=uninstrumented fun:sgetsgent=uninstrumented fun:sgetsgent_r=uninstrumented fun:sgetspent=uninstrumented fun:sgetspent_r=uninstrumented fun:shm_open=uninstrumented fun:shm_unlink=uninstrumented fun:shmat=uninstrumented fun:shmctl=uninstrumented fun:shmdt=uninstrumented fun:shmget=uninstrumented fun:shutdown=uninstrumented fun:sigaction=uninstrumented fun:sigaddset=uninstrumented fun:sigaltstack=uninstrumented fun:sigandset=uninstrumented fun:sigblock=uninstrumented fun:sigdelset=uninstrumented fun:sigemptyset=uninstrumented fun:sigfillset=uninstrumented fun:siggetmask=uninstrumented fun:sighold=uninstrumented fun:sigignore=uninstrumented fun:siginterrupt=uninstrumented fun:sigisemptyset=uninstrumented fun:sigismember=uninstrumented fun:siglongjmp=uninstrumented fun:signal=uninstrumented fun:signalfd=uninstrumented fun:significand=uninstrumented fun:significandf=uninstrumented fun:significandl=uninstrumented fun:sigorset=uninstrumented fun:sigpause=uninstrumented fun:sigpending=uninstrumented fun:sigprocmask=uninstrumented fun:sigqueue=uninstrumented fun:sigrelse=uninstrumented fun:sigreturn=uninstrumented fun:sigset=uninstrumented fun:sigsetmask=uninstrumented fun:sigstack=uninstrumented fun:sigsuspend=uninstrumented fun:sigtimedwait=uninstrumented fun:sigvec=uninstrumented fun:sigwait=uninstrumented fun:sigwaitinfo=uninstrumented fun:sin=uninstrumented fun:sincos=uninstrumented fun:sincosf=uninstrumented fun:sincosl=uninstrumented fun:sinf=uninstrumented fun:sinh=uninstrumented fun:sinhf=uninstrumented fun:sinhl=uninstrumented fun:sinl=uninstrumented fun:sleep=uninstrumented fun:snprintf=uninstrumented fun:sockatmark=uninstrumented fun:socket=uninstrumented fun:socketpair=uninstrumented fun:splice=uninstrumented fun:sprintf=uninstrumented fun:sprofil=uninstrumented fun:sqrt=uninstrumented fun:sqrtf=uninstrumented fun:sqrtl=uninstrumented fun:srand=uninstrumented fun:srand48=uninstrumented fun:srand48_r=uninstrumented fun:srandom=uninstrumented fun:srandom_r=uninstrumented fun:sscanf=uninstrumented fun:ssignal=uninstrumented fun:sstk=uninstrumented fun:stat=uninstrumented fun:stat64=uninstrumented fun:statfs=uninstrumented fun:statfs64=uninstrumented fun:statvfs=uninstrumented fun:statvfs64=uninstrumented fun:step=uninstrumented fun:stime=uninstrumented fun:stpcpy=uninstrumented fun:stpncpy=uninstrumented fun:strcasecmp=uninstrumented fun:strcasecmp_l=uninstrumented fun:strcasestr=uninstrumented fun:strcat=uninstrumented fun:strchr=uninstrumented fun:strchrnul=uninstrumented fun:strcmp=uninstrumented fun:strcoll=uninstrumented fun:strcoll_l=uninstrumented fun:strcpy=uninstrumented fun:strcspn=uninstrumented fun:strdup=uninstrumented fun:strerror=uninstrumented fun:strerror_l=uninstrumented fun:strerror_r=uninstrumented fun:strfmon=uninstrumented fun:strfmon_l=uninstrumented fun:strfry=uninstrumented fun:strftime=uninstrumented fun:strftime_l=uninstrumented fun:strlen=uninstrumented fun:strncasecmp=uninstrumented fun:strncasecmp_l=uninstrumented fun:strncat=uninstrumented fun:strncmp=uninstrumented fun:strncpy=uninstrumented fun:strndup=uninstrumented fun:strnlen=uninstrumented fun:strpbrk=uninstrumented fun:strptime=uninstrumented fun:strptime_l=uninstrumented fun:strrchr=uninstrumented fun:strsep=uninstrumented fun:strsignal=uninstrumented fun:strspn=uninstrumented fun:strstr=uninstrumented fun:strtod=uninstrumented fun:strtod_l=uninstrumented fun:strtof=uninstrumented fun:strtof_l=uninstrumented fun:strtoimax=uninstrumented fun:strtok=uninstrumented fun:strtok_r=uninstrumented fun:strtol=uninstrumented fun:strtol_l=uninstrumented fun:strtold=uninstrumented fun:strtold_l=uninstrumented fun:strtoll=uninstrumented fun:strtoll_l=uninstrumented fun:strtoq=uninstrumented fun:strtoul=uninstrumented fun:strtoul_l=uninstrumented fun:strtoull=uninstrumented fun:strtoull_l=uninstrumented fun:strtoumax=uninstrumented fun:strtouq=uninstrumented fun:strverscmp=uninstrumented fun:strxfrm=uninstrumented fun:strxfrm_l=uninstrumented fun:stty=uninstrumented fun:svc_exit=uninstrumented fun:svc_getreq=uninstrumented fun:svc_getreq_common=uninstrumented fun:svc_getreq_poll=uninstrumented fun:svc_getreqset=uninstrumented fun:svc_register=uninstrumented fun:svc_run=uninstrumented fun:svc_sendreply=uninstrumented fun:svc_unregister=uninstrumented fun:svcerr_auth=uninstrumented fun:svcerr_decode=uninstrumented fun:svcerr_noproc=uninstrumented fun:svcerr_noprog=uninstrumented fun:svcerr_progvers=uninstrumented fun:svcerr_systemerr=uninstrumented fun:svcerr_weakauth=uninstrumented fun:svcfd_create=uninstrumented fun:svcraw_create=uninstrumented fun:svctcp_create=uninstrumented fun:svcudp_bufcreate=uninstrumented fun:svcudp_create=uninstrumented fun:svcudp_enablecache=uninstrumented fun:svcunix_create=uninstrumented fun:svcunixfd_create=uninstrumented fun:swab=uninstrumented fun:swapcontext=uninstrumented fun:swapoff=uninstrumented fun:swapon=uninstrumented fun:swprintf=uninstrumented fun:swscanf=uninstrumented fun:symlink=uninstrumented fun:symlinkat=uninstrumented fun:sync=uninstrumented fun:sync_file_range=uninstrumented fun:syncfs=uninstrumented fun:syscall=uninstrumented fun:sysconf=uninstrumented fun:sysctl=uninstrumented fun:sysinfo=uninstrumented fun:syslog=uninstrumented fun:system=uninstrumented fun:sysv_signal=uninstrumented fun:tan=uninstrumented fun:tanf=uninstrumented fun:tanh=uninstrumented fun:tanhf=uninstrumented fun:tanhl=uninstrumented fun:tanl=uninstrumented fun:tcdrain=uninstrumented fun:tcflow=uninstrumented fun:tcflush=uninstrumented fun:tcgetattr=uninstrumented fun:tcgetpgrp=uninstrumented fun:tcgetsid=uninstrumented fun:tcsendbreak=uninstrumented fun:tcsetattr=uninstrumented fun:tcsetpgrp=uninstrumented fun:td_init=uninstrumented fun:td_log=uninstrumented fun:td_symbol_list=uninstrumented fun:td_ta_clear_event=uninstrumented fun:td_ta_delete=uninstrumented fun:td_ta_enable_stats=uninstrumented fun:td_ta_event_addr=uninstrumented fun:td_ta_event_getmsg=uninstrumented fun:td_ta_get_nthreads=uninstrumented fun:td_ta_get_ph=uninstrumented fun:td_ta_get_stats=uninstrumented fun:td_ta_map_id2thr=uninstrumented fun:td_ta_map_lwp2thr=uninstrumented fun:td_ta_new=uninstrumented fun:td_ta_reset_stats=uninstrumented fun:td_ta_set_event=uninstrumented fun:td_ta_setconcurrency=uninstrumented fun:td_ta_thr_iter=uninstrumented fun:td_ta_tsd_iter=uninstrumented fun:td_thr_clear_event=uninstrumented fun:td_thr_dbresume=uninstrumented fun:td_thr_dbsuspend=uninstrumented fun:td_thr_event_enable=uninstrumented fun:td_thr_event_getmsg=uninstrumented fun:td_thr_get_info=uninstrumented fun:td_thr_getfpregs=uninstrumented fun:td_thr_getgregs=uninstrumented fun:td_thr_getxregs=uninstrumented fun:td_thr_getxregsize=uninstrumented fun:td_thr_set_event=uninstrumented fun:td_thr_setfpregs=uninstrumented fun:td_thr_setgregs=uninstrumented fun:td_thr_setprio=uninstrumented fun:td_thr_setsigpending=uninstrumented fun:td_thr_setxregs=uninstrumented fun:td_thr_sigsetmask=uninstrumented fun:td_thr_tls_get_addr=uninstrumented fun:td_thr_tlsbase=uninstrumented fun:td_thr_tsd=uninstrumented fun:td_thr_validate=uninstrumented fun:tdelete=uninstrumented fun:tdestroy=uninstrumented fun:tee=uninstrumented fun:telldir=uninstrumented fun:tempnam=uninstrumented fun:textdomain=uninstrumented fun:tfind=uninstrumented fun:tgamma=uninstrumented fun:tgammaf=uninstrumented fun:tgammal=uninstrumented fun:time=uninstrumented fun:timegm=uninstrumented fun:timelocal=uninstrumented fun:timer_create=uninstrumented fun:timer_delete=uninstrumented fun:timer_getoverrun=uninstrumented fun:timer_gettime=uninstrumented fun:timer_settime=uninstrumented fun:timerfd_create=uninstrumented fun:timerfd_gettime=uninstrumented fun:timerfd_settime=uninstrumented fun:times=uninstrumented fun:timespec_get=uninstrumented fun:tmpfile=uninstrumented fun:tmpfile64=uninstrumented fun:tmpnam=uninstrumented fun:tmpnam_r=uninstrumented fun:toascii=uninstrumented fun:tolower=uninstrumented fun:tolower_l=uninstrumented fun:toupper=uninstrumented fun:toupper_l=uninstrumented fun:towctrans=uninstrumented fun:towctrans_l=uninstrumented fun:towlower=uninstrumented fun:towlower_l=uninstrumented fun:towupper=uninstrumented fun:towupper_l=uninstrumented fun:tr_break=uninstrumented fun:trunc=uninstrumented fun:truncate=uninstrumented fun:truncate64=uninstrumented fun:truncf=uninstrumented fun:truncl=uninstrumented fun:tsearch=uninstrumented fun:ttyname=uninstrumented fun:ttyname_r=uninstrumented fun:ttyslot=uninstrumented fun:twalk=uninstrumented fun:tzset=uninstrumented fun:ualarm=uninstrumented fun:ulckpwdf=uninstrumented fun:ulimit=uninstrumented fun:umask=uninstrumented fun:umount=uninstrumented fun:umount2=uninstrumented fun:uname=uninstrumented fun:ungetc=uninstrumented fun:ungetwc=uninstrumented fun:unlink=uninstrumented fun:unlinkat=uninstrumented fun:unlockpt=uninstrumented fun:unsetenv=uninstrumented fun:unshare=uninstrumented fun:updwtmp=uninstrumented fun:updwtmpx=uninstrumented fun:uselib=uninstrumented fun:uselocale=uninstrumented fun:user2netname=uninstrumented fun:usleep=uninstrumented fun:ustat=uninstrumented fun:utime=uninstrumented fun:utimensat=uninstrumented fun:utimes=uninstrumented fun:utmpname=uninstrumented fun:utmpxname=uninstrumented fun:valloc=uninstrumented fun:vasprintf=uninstrumented fun:vdprintf=uninstrumented fun:verr=uninstrumented fun:verrx=uninstrumented fun:versionsort=uninstrumented fun:versionsort64=uninstrumented fun:vfork=uninstrumented fun:vfprintf=uninstrumented fun:vfscanf=uninstrumented fun:vfwprintf=uninstrumented fun:vfwscanf=uninstrumented fun:vhangup=uninstrumented fun:vlimit=uninstrumented fun:vmsplice=uninstrumented fun:vprintf=uninstrumented fun:vscanf=uninstrumented fun:vsnprintf=uninstrumented fun:vsprintf=uninstrumented fun:vsscanf=uninstrumented fun:vswprintf=uninstrumented fun:vswscanf=uninstrumented fun:vsyslog=uninstrumented fun:vtimes=uninstrumented fun:vwarn=uninstrumented fun:vwarnx=uninstrumented fun:vwprintf=uninstrumented fun:vwscanf=uninstrumented fun:wait=uninstrumented fun:wait3=uninstrumented fun:wait4=uninstrumented fun:waitid=uninstrumented fun:waitpid=uninstrumented fun:warn=uninstrumented fun:warnx=uninstrumented fun:wcpcpy=uninstrumented fun:wcpncpy=uninstrumented fun:wcrtomb=uninstrumented fun:wcscasecmp=uninstrumented fun:wcscasecmp_l=uninstrumented fun:wcscat=uninstrumented fun:wcschr=uninstrumented fun:wcschrnul=uninstrumented fun:wcscmp=uninstrumented fun:wcscoll=uninstrumented fun:wcscoll_l=uninstrumented fun:wcscpy=uninstrumented fun:wcscspn=uninstrumented fun:wcsdup=uninstrumented fun:wcsftime=uninstrumented fun:wcsftime_l=uninstrumented fun:wcslen=uninstrumented fun:wcsncasecmp=uninstrumented fun:wcsncasecmp_l=uninstrumented fun:wcsncat=uninstrumented fun:wcsncmp=uninstrumented fun:wcsncpy=uninstrumented fun:wcsnlen=uninstrumented fun:wcsnrtombs=uninstrumented fun:wcspbrk=uninstrumented fun:wcsrchr=uninstrumented fun:wcsrtombs=uninstrumented fun:wcsspn=uninstrumented fun:wcsstr=uninstrumented fun:wcstod=uninstrumented fun:wcstod_l=uninstrumented fun:wcstof=uninstrumented fun:wcstof_l=uninstrumented fun:wcstoimax=uninstrumented fun:wcstok=uninstrumented fun:wcstol=uninstrumented fun:wcstol_l=uninstrumented fun:wcstold=uninstrumented fun:wcstold_l=uninstrumented fun:wcstoll=uninstrumented fun:wcstoll_l=uninstrumented fun:wcstombs=uninstrumented fun:wcstoq=uninstrumented fun:wcstoul=uninstrumented fun:wcstoul_l=uninstrumented fun:wcstoull=uninstrumented fun:wcstoull_l=uninstrumented fun:wcstoumax=uninstrumented fun:wcstouq=uninstrumented fun:wcswcs=uninstrumented fun:wcswidth=uninstrumented fun:wcsxfrm=uninstrumented fun:wcsxfrm_l=uninstrumented fun:wctob=uninstrumented fun:wctomb=uninstrumented fun:wctrans=uninstrumented fun:wctrans_l=uninstrumented fun:wctype=uninstrumented fun:wctype_l=uninstrumented fun:wcwidth=uninstrumented fun:wmemchr=uninstrumented fun:wmemcmp=uninstrumented fun:wmemcpy=uninstrumented fun:wmemmove=uninstrumented fun:wmempcpy=uninstrumented fun:wmemset=uninstrumented fun:wordexp=uninstrumented fun:wordfree=uninstrumented fun:wprintf=uninstrumented fun:write=uninstrumented fun:writeColdStartFile=uninstrumented fun:writev=uninstrumented fun:wscanf=uninstrumented fun:xdecrypt=uninstrumented fun:xdr_accepted_reply=uninstrumented fun:xdr_array=uninstrumented fun:xdr_authdes_cred=uninstrumented fun:xdr_authdes_verf=uninstrumented fun:xdr_authunix_parms=uninstrumented fun:xdr_bool=uninstrumented fun:xdr_bytes=uninstrumented fun:xdr_callhdr=uninstrumented fun:xdr_callmsg=uninstrumented fun:xdr_cback_data=uninstrumented fun:xdr_char=uninstrumented fun:xdr_cryptkeyarg=uninstrumented fun:xdr_cryptkeyarg2=uninstrumented fun:xdr_cryptkeyres=uninstrumented fun:xdr_des_block=uninstrumented fun:xdr_domainname=uninstrumented fun:xdr_double=uninstrumented fun:xdr_enum=uninstrumented fun:xdr_float=uninstrumented fun:xdr_free=uninstrumented fun:xdr_getcredres=uninstrumented fun:xdr_hyper=uninstrumented fun:xdr_int=uninstrumented fun:xdr_int16_t=uninstrumented fun:xdr_int32_t=uninstrumented fun:xdr_int64_t=uninstrumented fun:xdr_int8_t=uninstrumented fun:xdr_key_netstarg=uninstrumented fun:xdr_key_netstres=uninstrumented fun:xdr_keybuf=uninstrumented fun:xdr_keydat=uninstrumented fun:xdr_keystatus=uninstrumented fun:xdr_long=uninstrumented fun:xdr_longlong_t=uninstrumented fun:xdr_mapname=uninstrumented fun:xdr_netnamestr=uninstrumented fun:xdr_netobj=uninstrumented fun:xdr_obj_p=uninstrumented fun:xdr_opaque=uninstrumented fun:xdr_opaque_auth=uninstrumented fun:xdr_peername=uninstrumented fun:xdr_pmap=uninstrumented fun:xdr_pmaplist=uninstrumented fun:xdr_pointer=uninstrumented fun:xdr_quad_t=uninstrumented fun:xdr_reference=uninstrumented fun:xdr_rejected_reply=uninstrumented fun:xdr_replymsg=uninstrumented fun:xdr_rmtcall_args=uninstrumented fun:xdr_rmtcallres=uninstrumented fun:xdr_short=uninstrumented fun:xdr_sizeof=uninstrumented fun:xdr_string=uninstrumented fun:xdr_u_char=uninstrumented fun:xdr_u_hyper=uninstrumented fun:xdr_u_int=uninstrumented fun:xdr_u_long=uninstrumented fun:xdr_u_longlong_t=uninstrumented fun:xdr_u_quad_t=uninstrumented fun:xdr_u_short=uninstrumented fun:xdr_uint16_t=uninstrumented fun:xdr_uint32_t=uninstrumented fun:xdr_uint64_t=uninstrumented fun:xdr_uint8_t=uninstrumented fun:xdr_union=uninstrumented fun:xdr_unixcred=uninstrumented fun:xdr_valdat=uninstrumented fun:xdr_vector=uninstrumented fun:xdr_void=uninstrumented fun:xdr_wrapstring=uninstrumented fun:xdr_yp_buf=uninstrumented fun:xdr_ypall=uninstrumented fun:xdr_ypbind_binding=uninstrumented fun:xdr_ypbind_resp=uninstrumented fun:xdr_ypbind_resptype=uninstrumented fun:xdr_ypbind_setdom=uninstrumented fun:xdr_ypdelete_args=uninstrumented fun:xdr_ypmap_parms=uninstrumented fun:xdr_ypmaplist=uninstrumented fun:xdr_yppush_status=uninstrumented fun:xdr_yppushresp_xfr=uninstrumented fun:xdr_ypreq_key=uninstrumented fun:xdr_ypreq_nokey=uninstrumented fun:xdr_ypreq_xfr=uninstrumented fun:xdr_ypresp_all=uninstrumented fun:xdr_ypresp_key_val=uninstrumented fun:xdr_ypresp_maplist=uninstrumented fun:xdr_ypresp_master=uninstrumented fun:xdr_ypresp_order=uninstrumented fun:xdr_ypresp_val=uninstrumented fun:xdr_ypresp_xfr=uninstrumented fun:xdr_ypstat=uninstrumented fun:xdr_ypupdate_args=uninstrumented fun:xdr_ypxfrstat=uninstrumented fun:xdrmem_create=uninstrumented fun:xdrrec_create=uninstrumented fun:xdrrec_endofrecord=uninstrumented fun:xdrrec_eof=uninstrumented fun:xdrrec_skiprecord=uninstrumented fun:xdrstdio_create=uninstrumented fun:xencrypt=uninstrumented fun:xprt_register=uninstrumented fun:xprt_unregister=uninstrumented fun:y0=uninstrumented fun:y0f=uninstrumented fun:y0l=uninstrumented fun:y1=uninstrumented fun:y1f=uninstrumented fun:y1l=uninstrumented fun:yn=uninstrumented fun:ynf=uninstrumented fun:ynl=uninstrumented fun:yp_all=uninstrumented fun:yp_bind=uninstrumented fun:yp_first=uninstrumented fun:yp_get_default_domain=uninstrumented fun:yp_maplist=uninstrumented fun:yp_master=uninstrumented fun:yp_match=uninstrumented fun:yp_next=uninstrumented fun:yp_order=uninstrumented fun:yp_unbind=uninstrumented fun:yp_update=uninstrumented fun:ypbinderr_string=uninstrumented fun:yperr_string=uninstrumented fun:ypprot_err=uninstrumented ================================================ FILE: runtime/dfsan/libc_ubuntu1804_abilist.txt ================================================ fun:_Exit=uninstrumented fun:_IO_adjust_column=uninstrumented fun:_IO_adjust_wcolumn=uninstrumented fun:_IO_default_doallocate=uninstrumented fun:_IO_default_finish=uninstrumented fun:_IO_default_pbackfail=uninstrumented fun:_IO_default_uflow=uninstrumented fun:_IO_default_xsgetn=uninstrumented fun:_IO_default_xsputn=uninstrumented fun:_IO_do_write=uninstrumented fun:_IO_doallocbuf=uninstrumented fun:_IO_enable_locks=uninstrumented fun:_IO_fclose=uninstrumented fun:_IO_fdopen=uninstrumented fun:_IO_feof=uninstrumented fun:_IO_ferror=uninstrumented fun:_IO_fflush=uninstrumented fun:_IO_fgetpos=uninstrumented fun:_IO_fgetpos64=uninstrumented fun:_IO_fgets=uninstrumented fun:_IO_file_attach=uninstrumented fun:_IO_file_close=uninstrumented fun:_IO_file_close_it=uninstrumented fun:_IO_file_doallocate=uninstrumented fun:_IO_file_finish=uninstrumented fun:_IO_file_fopen=uninstrumented fun:_IO_file_init=uninstrumented fun:_IO_file_open=uninstrumented fun:_IO_file_overflow=uninstrumented fun:_IO_file_read=uninstrumented fun:_IO_file_seek=uninstrumented fun:_IO_file_seekoff=uninstrumented fun:_IO_file_setbuf=uninstrumented fun:_IO_file_stat=uninstrumented fun:_IO_file_sync=uninstrumented fun:_IO_file_underflow=uninstrumented fun:_IO_file_write=uninstrumented fun:_IO_file_xsputn=uninstrumented fun:_IO_flockfile=uninstrumented fun:_IO_flush_all=uninstrumented fun:_IO_flush_all_linebuffered=uninstrumented fun:_IO_fopen=uninstrumented fun:_IO_fprintf=uninstrumented fun:_IO_fputs=uninstrumented fun:_IO_fread=uninstrumented fun:_IO_free_backup_area=uninstrumented fun:_IO_free_wbackup_area=uninstrumented fun:_IO_fsetpos=uninstrumented fun:_IO_fsetpos64=uninstrumented fun:_IO_ftell=uninstrumented fun:_IO_ftrylockfile=uninstrumented fun:_IO_funlockfile=uninstrumented fun:_IO_fwrite=uninstrumented fun:_IO_getc=uninstrumented fun:_IO_getline=uninstrumented fun:_IO_getline_info=uninstrumented fun:_IO_gets=uninstrumented fun:_IO_init=uninstrumented fun:_IO_init_marker=uninstrumented fun:_IO_init_wmarker=uninstrumented fun:_IO_iter_begin=uninstrumented fun:_IO_iter_end=uninstrumented fun:_IO_iter_file=uninstrumented fun:_IO_iter_next=uninstrumented fun:_IO_least_wmarker=uninstrumented fun:_IO_link_in=uninstrumented fun:_IO_list_lock=uninstrumented fun:_IO_list_resetlock=uninstrumented fun:_IO_list_unlock=uninstrumented fun:_IO_marker_delta=uninstrumented fun:_IO_marker_difference=uninstrumented fun:_IO_padn=uninstrumented fun:_IO_peekc_locked=uninstrumented fun:_IO_popen=uninstrumented fun:_IO_printf=uninstrumented fun:_IO_proc_close=uninstrumented fun:_IO_proc_open=uninstrumented fun:_IO_putc=uninstrumented fun:_IO_puts=uninstrumented fun:_IO_remove_marker=uninstrumented fun:_IO_seekmark=uninstrumented fun:_IO_seekoff=uninstrumented fun:_IO_seekpos=uninstrumented fun:_IO_seekwmark=uninstrumented fun:_IO_setb=uninstrumented fun:_IO_setbuffer=uninstrumented fun:_IO_setvbuf=uninstrumented fun:_IO_sgetn=uninstrumented fun:_IO_sprintf=uninstrumented fun:_IO_sputbackc=uninstrumented fun:_IO_sputbackwc=uninstrumented fun:_IO_sscanf=uninstrumented fun:_IO_str_init_readonly=uninstrumented fun:_IO_str_init_static=uninstrumented fun:_IO_str_overflow=uninstrumented fun:_IO_str_pbackfail=uninstrumented fun:_IO_str_seekoff=uninstrumented fun:_IO_str_underflow=uninstrumented fun:_IO_sungetc=uninstrumented fun:_IO_sungetwc=uninstrumented fun:_IO_switch_to_get_mode=uninstrumented fun:_IO_switch_to_main_wget_area=uninstrumented fun:_IO_switch_to_wbackup_area=uninstrumented fun:_IO_switch_to_wget_mode=uninstrumented fun:_IO_un_link=uninstrumented fun:_IO_ungetc=uninstrumented fun:_IO_unsave_markers=uninstrumented fun:_IO_unsave_wmarkers=uninstrumented fun:_IO_vfprintf=uninstrumented fun:_IO_vfscanf=uninstrumented fun:_IO_vsprintf=uninstrumented fun:_IO_wdefault_doallocate=uninstrumented fun:_IO_wdefault_finish=uninstrumented fun:_IO_wdefault_pbackfail=uninstrumented fun:_IO_wdefault_uflow=uninstrumented fun:_IO_wdefault_xsgetn=uninstrumented fun:_IO_wdefault_xsputn=uninstrumented fun:_IO_wdo_write=uninstrumented fun:_IO_wdoallocbuf=uninstrumented fun:_IO_wfile_overflow=uninstrumented fun:_IO_wfile_seekoff=uninstrumented fun:_IO_wfile_sync=uninstrumented fun:_IO_wfile_underflow=uninstrumented fun:_IO_wfile_xsputn=uninstrumented fun:_IO_wmarker_delta=uninstrumented fun:_IO_wsetb=uninstrumented fun:_Unwind_Backtrace=uninstrumented fun:_Unwind_DeleteException=uninstrumented fun:_Unwind_FindEnclosingFunction=uninstrumented fun:_Unwind_Find_FDE=uninstrumented fun:_Unwind_ForcedUnwind=uninstrumented fun:_Unwind_GetCFA=uninstrumented fun:_Unwind_GetDataRelBase=uninstrumented fun:_Unwind_GetGR=uninstrumented fun:_Unwind_GetIP=uninstrumented fun:_Unwind_GetIPInfo=uninstrumented fun:_Unwind_GetLanguageSpecificData=uninstrumented fun:_Unwind_GetRegionStart=uninstrumented fun:_Unwind_GetTextRelBase=uninstrumented fun:_Unwind_RaiseException=uninstrumented fun:_Unwind_Resume=uninstrumented fun:_Unwind_Resume_or_Rethrow=uninstrumented fun:_Unwind_SetGR=uninstrumented fun:_Unwind_SetIP=uninstrumented fun:__absvdi2=uninstrumented fun:__absvsi2=uninstrumented fun:__absvti2=uninstrumented fun:__acos_finite=uninstrumented fun:__acosf128_finite=uninstrumented fun:__acosf_finite=uninstrumented fun:__acosh_finite=uninstrumented fun:__acoshf128_finite=uninstrumented fun:__acoshf_finite=uninstrumented fun:__acoshl_finite=uninstrumented fun:__acosl_finite=uninstrumented fun:__addtf3=uninstrumented fun:__addvdi3=uninstrumented fun:__addvsi3=uninstrumented fun:__addvti3=uninstrumented fun:__adjtimex=uninstrumented fun:__arch_prctl=uninstrumented fun:__argz_count=uninstrumented fun:__argz_next=uninstrumented fun:__argz_stringify=uninstrumented fun:__ashlti3=uninstrumented fun:__ashrti3=uninstrumented fun:__asin_finite=uninstrumented fun:__asinf128_finite=uninstrumented fun:__asinf_finite=uninstrumented fun:__asinl_finite=uninstrumented fun:__asprintf=uninstrumented fun:__asprintf_chk=uninstrumented fun:__assert=uninstrumented fun:__assert_fail=uninstrumented fun:__assert_perror_fail=uninstrumented fun:__atan2_finite=uninstrumented fun:__atan2f128_finite=uninstrumented fun:__atan2f_finite=uninstrumented fun:__atan2l_finite=uninstrumented fun:__atanh_finite=uninstrumented fun:__atanhf128_finite=uninstrumented fun:__atanhf_finite=uninstrumented fun:__atanhl_finite=uninstrumented fun:__b64_ntop=uninstrumented fun:__b64_pton=uninstrumented fun:__backtrace=uninstrumented fun:__backtrace_symbols=uninstrumented fun:__backtrace_symbols_fd=uninstrumented fun:__bid128_abs=uninstrumented fun:__bid128_add=uninstrumented fun:__bid128_class=uninstrumented fun:__bid128_copy=uninstrumented fun:__bid128_copySign=uninstrumented fun:__bid128_div=uninstrumented fun:__bid128_fma=uninstrumented fun:__bid128_from_int32=uninstrumented fun:__bid128_from_int64=uninstrumented fun:__bid128_from_uint32=uninstrumented fun:__bid128_from_uint64=uninstrumented fun:__bid128_isCanonical=uninstrumented fun:__bid128_isFinite=uninstrumented fun:__bid128_isInf=uninstrumented fun:__bid128_isNaN=uninstrumented fun:__bid128_isNormal=uninstrumented fun:__bid128_isSignaling=uninstrumented fun:__bid128_isSigned=uninstrumented fun:__bid128_isSubnormal=uninstrumented fun:__bid128_isZero=uninstrumented fun:__bid128_mul=uninstrumented fun:__bid128_negate=uninstrumented fun:__bid128_quiet_equal=uninstrumented fun:__bid128_quiet_greater=uninstrumented fun:__bid128_quiet_greater_equal=uninstrumented fun:__bid128_quiet_greater_unordered=uninstrumented fun:__bid128_quiet_less=uninstrumented fun:__bid128_quiet_less_equal=uninstrumented fun:__bid128_quiet_less_unordered=uninstrumented fun:__bid128_quiet_not_equal=uninstrumented fun:__bid128_quiet_not_greater=uninstrumented fun:__bid128_quiet_not_less=uninstrumented fun:__bid128_quiet_ordered=uninstrumented fun:__bid128_quiet_unordered=uninstrumented fun:__bid128_radix=uninstrumented fun:__bid128_sameQuantum=uninstrumented fun:__bid128_signaling_greater=uninstrumented fun:__bid128_signaling_greater_equal=uninstrumented fun:__bid128_signaling_greater_unordered=uninstrumented fun:__bid128_signaling_less=uninstrumented fun:__bid128_signaling_less_equal=uninstrumented fun:__bid128_signaling_less_unordered=uninstrumented fun:__bid128_signaling_not_greater=uninstrumented fun:__bid128_signaling_not_less=uninstrumented fun:__bid128_sub=uninstrumented fun:__bid128_to_bid32=uninstrumented fun:__bid128_to_bid64=uninstrumented fun:__bid128_to_binary128=uninstrumented fun:__bid128_to_binary32=uninstrumented fun:__bid128_to_binary64=uninstrumented fun:__bid128_to_binary80=uninstrumented fun:__bid128_to_int32_ceil=uninstrumented fun:__bid128_to_int32_floor=uninstrumented fun:__bid128_to_int32_int=uninstrumented fun:__bid128_to_int32_rnint=uninstrumented fun:__bid128_to_int32_rninta=uninstrumented fun:__bid128_to_int32_xceil=uninstrumented fun:__bid128_to_int32_xfloor=uninstrumented fun:__bid128_to_int32_xint=uninstrumented fun:__bid128_to_int32_xrnint=uninstrumented fun:__bid128_to_int32_xrninta=uninstrumented fun:__bid128_to_int64_ceil=uninstrumented fun:__bid128_to_int64_floor=uninstrumented fun:__bid128_to_int64_int=uninstrumented fun:__bid128_to_int64_rnint=uninstrumented fun:__bid128_to_int64_rninta=uninstrumented fun:__bid128_to_int64_xceil=uninstrumented fun:__bid128_to_int64_xfloor=uninstrumented fun:__bid128_to_int64_xint=uninstrumented fun:__bid128_to_int64_xrnint=uninstrumented fun:__bid128_to_int64_xrninta=uninstrumented fun:__bid128_to_uint32_ceil=uninstrumented fun:__bid128_to_uint32_floor=uninstrumented fun:__bid128_to_uint32_int=uninstrumented fun:__bid128_to_uint32_rnint=uninstrumented fun:__bid128_to_uint32_rninta=uninstrumented fun:__bid128_to_uint32_xceil=uninstrumented fun:__bid128_to_uint32_xfloor=uninstrumented fun:__bid128_to_uint32_xint=uninstrumented fun:__bid128_to_uint32_xrnint=uninstrumented fun:__bid128_to_uint32_xrninta=uninstrumented fun:__bid128_to_uint64_ceil=uninstrumented fun:__bid128_to_uint64_floor=uninstrumented fun:__bid128_to_uint64_int=uninstrumented fun:__bid128_to_uint64_rnint=uninstrumented fun:__bid128_to_uint64_rninta=uninstrumented fun:__bid128_to_uint64_xceil=uninstrumented fun:__bid128_to_uint64_xfloor=uninstrumented fun:__bid128_to_uint64_xint=uninstrumented fun:__bid128_to_uint64_xrnint=uninstrumented fun:__bid128_to_uint64_xrninta=uninstrumented fun:__bid128_totalOrder=uninstrumented fun:__bid128_totalOrderMag=uninstrumented fun:__bid128dd_add=uninstrumented fun:__bid128dd_div=uninstrumented fun:__bid128dd_mul=uninstrumented fun:__bid128dd_sub=uninstrumented fun:__bid128ddd_fma=uninstrumented fun:__bid128ddq_fma=uninstrumented fun:__bid128dq_add=uninstrumented fun:__bid128dq_div=uninstrumented fun:__bid128dq_mul=uninstrumented fun:__bid128dq_sub=uninstrumented fun:__bid128dqd_fma=uninstrumented fun:__bid128dqq_fma=uninstrumented fun:__bid128qd_add=uninstrumented fun:__bid128qd_div=uninstrumented fun:__bid128qd_mul=uninstrumented fun:__bid128qd_sub=uninstrumented fun:__bid128qdd_fma=uninstrumented fun:__bid128qdq_fma=uninstrumented fun:__bid128qqd_fma=uninstrumented fun:__bid32_to_bid128=uninstrumented fun:__bid32_to_bid64=uninstrumented fun:__bid32_to_binary128=uninstrumented fun:__bid32_to_binary32=uninstrumented fun:__bid32_to_binary64=uninstrumented fun:__bid32_to_binary80=uninstrumented fun:__bid64_abs=uninstrumented fun:__bid64_add=uninstrumented fun:__bid64_class=uninstrumented fun:__bid64_copy=uninstrumented fun:__bid64_copySign=uninstrumented fun:__bid64_div=uninstrumented fun:__bid64_from_int32=uninstrumented fun:__bid64_from_int64=uninstrumented fun:__bid64_from_uint32=uninstrumented fun:__bid64_from_uint64=uninstrumented fun:__bid64_isCanonical=uninstrumented fun:__bid64_isFinite=uninstrumented fun:__bid64_isInf=uninstrumented fun:__bid64_isNaN=uninstrumented fun:__bid64_isNormal=uninstrumented fun:__bid64_isSignaling=uninstrumented fun:__bid64_isSigned=uninstrumented fun:__bid64_isSubnormal=uninstrumented fun:__bid64_isZero=uninstrumented fun:__bid64_mul=uninstrumented fun:__bid64_negate=uninstrumented fun:__bid64_quiet_equal=uninstrumented fun:__bid64_quiet_greater=uninstrumented fun:__bid64_quiet_greater_equal=uninstrumented fun:__bid64_quiet_greater_unordered=uninstrumented fun:__bid64_quiet_less=uninstrumented fun:__bid64_quiet_less_equal=uninstrumented fun:__bid64_quiet_less_unordered=uninstrumented fun:__bid64_quiet_not_equal=uninstrumented fun:__bid64_quiet_not_greater=uninstrumented fun:__bid64_quiet_not_less=uninstrumented fun:__bid64_quiet_ordered=uninstrumented fun:__bid64_quiet_unordered=uninstrumented fun:__bid64_radix=uninstrumented fun:__bid64_sameQuantum=uninstrumented fun:__bid64_signaling_greater=uninstrumented fun:__bid64_signaling_greater_equal=uninstrumented fun:__bid64_signaling_greater_unordered=uninstrumented fun:__bid64_signaling_less=uninstrumented fun:__bid64_signaling_less_equal=uninstrumented fun:__bid64_signaling_less_unordered=uninstrumented fun:__bid64_signaling_not_greater=uninstrumented fun:__bid64_signaling_not_less=uninstrumented fun:__bid64_sub=uninstrumented fun:__bid64_to_bid128=uninstrumented fun:__bid64_to_bid32=uninstrumented fun:__bid64_to_binary128=uninstrumented fun:__bid64_to_binary32=uninstrumented fun:__bid64_to_binary64=uninstrumented fun:__bid64_to_binary80=uninstrumented fun:__bid64_to_int32_ceil=uninstrumented fun:__bid64_to_int32_floor=uninstrumented fun:__bid64_to_int32_int=uninstrumented fun:__bid64_to_int32_rnint=uninstrumented fun:__bid64_to_int32_rninta=uninstrumented fun:__bid64_to_int32_xceil=uninstrumented fun:__bid64_to_int32_xfloor=uninstrumented fun:__bid64_to_int32_xint=uninstrumented fun:__bid64_to_int32_xrnint=uninstrumented fun:__bid64_to_int32_xrninta=uninstrumented fun:__bid64_to_int64_ceil=uninstrumented fun:__bid64_to_int64_floor=uninstrumented fun:__bid64_to_int64_int=uninstrumented fun:__bid64_to_int64_rnint=uninstrumented fun:__bid64_to_int64_rninta=uninstrumented fun:__bid64_to_int64_xceil=uninstrumented fun:__bid64_to_int64_xfloor=uninstrumented fun:__bid64_to_int64_xint=uninstrumented fun:__bid64_to_int64_xrnint=uninstrumented fun:__bid64_to_int64_xrninta=uninstrumented fun:__bid64_to_uint32_ceil=uninstrumented fun:__bid64_to_uint32_floor=uninstrumented fun:__bid64_to_uint32_int=uninstrumented fun:__bid64_to_uint32_rnint=uninstrumented fun:__bid64_to_uint32_rninta=uninstrumented fun:__bid64_to_uint32_xceil=uninstrumented fun:__bid64_to_uint32_xfloor=uninstrumented fun:__bid64_to_uint32_xint=uninstrumented fun:__bid64_to_uint32_xrnint=uninstrumented fun:__bid64_to_uint32_xrninta=uninstrumented fun:__bid64_to_uint64_ceil=uninstrumented fun:__bid64_to_uint64_floor=uninstrumented fun:__bid64_to_uint64_int=uninstrumented fun:__bid64_to_uint64_rnint=uninstrumented fun:__bid64_to_uint64_rninta=uninstrumented fun:__bid64_to_uint64_xceil=uninstrumented fun:__bid64_to_uint64_xfloor=uninstrumented fun:__bid64_to_uint64_xint=uninstrumented fun:__bid64_to_uint64_xrnint=uninstrumented fun:__bid64_to_uint64_xrninta=uninstrumented fun:__bid64_totalOrder=uninstrumented fun:__bid64_totalOrderMag=uninstrumented fun:__bid64ddq_fma=uninstrumented fun:__bid64dq_add=uninstrumented fun:__bid64dq_div=uninstrumented fun:__bid64dq_mul=uninstrumented fun:__bid64dq_sub=uninstrumented fun:__bid64dqd_fma=uninstrumented fun:__bid64dqq_fma=uninstrumented fun:__bid64qd_add=uninstrumented fun:__bid64qd_div=uninstrumented fun:__bid64qd_mul=uninstrumented fun:__bid64qd_sub=uninstrumented fun:__bid64qdd_fma=uninstrumented fun:__bid64qdq_fma=uninstrumented fun:__bid64qq_add=uninstrumented fun:__bid64qq_div=uninstrumented fun:__bid64qq_mul=uninstrumented fun:__bid64qq_sub=uninstrumented fun:__bid64qqd_fma=uninstrumented fun:__bid64qqq_fma=uninstrumented fun:__bid_adddd3=uninstrumented fun:__bid_addsd3=uninstrumented fun:__bid_addtd3=uninstrumented fun:__bid_divdd3=uninstrumented fun:__bid_divsd3=uninstrumented fun:__bid_divtd3=uninstrumented fun:__bid_eqdd2=uninstrumented fun:__bid_eqsd2=uninstrumented fun:__bid_eqtd2=uninstrumented fun:__bid_extendddtd2=uninstrumented fun:__bid_extendddtf=uninstrumented fun:__bid_extendddxf=uninstrumented fun:__bid_extenddfdd=uninstrumented fun:__bid_extenddftd=uninstrumented fun:__bid_extendsddd2=uninstrumented fun:__bid_extendsddf=uninstrumented fun:__bid_extendsdtd2=uninstrumented fun:__bid_extendsdtf=uninstrumented fun:__bid_extendsdxf=uninstrumented fun:__bid_extendsfdd=uninstrumented fun:__bid_extendsfsd=uninstrumented fun:__bid_extendsftd=uninstrumented fun:__bid_extendtftd=uninstrumented fun:__bid_extendxftd=uninstrumented fun:__bid_fixdddi=uninstrumented fun:__bid_fixddsi=uninstrumented fun:__bid_fixsddi=uninstrumented fun:__bid_fixsdsi=uninstrumented fun:__bid_fixtddi=uninstrumented fun:__bid_fixtdsi=uninstrumented fun:__bid_fixunsdddi=uninstrumented fun:__bid_fixunsddsi=uninstrumented fun:__bid_fixunssddi=uninstrumented fun:__bid_fixunssdsi=uninstrumented fun:__bid_fixunstddi=uninstrumented fun:__bid_fixunstdsi=uninstrumented fun:__bid_floatdidd=uninstrumented fun:__bid_floatdisd=uninstrumented fun:__bid_floatditd=uninstrumented fun:__bid_floatsidd=uninstrumented fun:__bid_floatsisd=uninstrumented fun:__bid_floatsitd=uninstrumented fun:__bid_floatunsdidd=uninstrumented fun:__bid_floatunsdisd=uninstrumented fun:__bid_floatunsditd=uninstrumented fun:__bid_floatunssidd=uninstrumented fun:__bid_floatunssisd=uninstrumented fun:__bid_floatunssitd=uninstrumented fun:__bid_gedd2=uninstrumented fun:__bid_gesd2=uninstrumented fun:__bid_getd2=uninstrumented fun:__bid_gtdd2=uninstrumented fun:__bid_gtsd2=uninstrumented fun:__bid_gttd2=uninstrumented fun:__bid_ledd2=uninstrumented fun:__bid_lesd2=uninstrumented fun:__bid_letd2=uninstrumented fun:__bid_ltdd2=uninstrumented fun:__bid_ltsd2=uninstrumented fun:__bid_lttd2=uninstrumented fun:__bid_muldd3=uninstrumented fun:__bid_mulsd3=uninstrumented fun:__bid_multd3=uninstrumented fun:__bid_nedd2=uninstrumented fun:__bid_nesd2=uninstrumented fun:__bid_netd2=uninstrumented fun:__bid_round128_19_38=uninstrumented fun:__bid_round192_39_57=uninstrumented fun:__bid_round256_58_76=uninstrumented fun:__bid_round64_2_18=uninstrumented fun:__bid_subdd3=uninstrumented fun:__bid_subsd3=uninstrumented fun:__bid_subtd3=uninstrumented fun:__bid_truncdddf=uninstrumented fun:__bid_truncddsd2=uninstrumented fun:__bid_truncddsf=uninstrumented fun:__bid_truncdfsd=uninstrumented fun:__bid_truncsdsf=uninstrumented fun:__bid_trunctddd2=uninstrumented fun:__bid_trunctddf=uninstrumented fun:__bid_trunctdsd2=uninstrumented fun:__bid_trunctdsf=uninstrumented fun:__bid_trunctdtf=uninstrumented fun:__bid_trunctdxf=uninstrumented fun:__bid_trunctfdd=uninstrumented fun:__bid_trunctfsd=uninstrumented fun:__bid_truncxfdd=uninstrumented fun:__bid_truncxfsd=uninstrumented fun:__bid_unorddd2=uninstrumented fun:__bid_unordsd2=uninstrumented fun:__bid_unordtd2=uninstrumented fun:__binary128_to_bid128=uninstrumented fun:__binary128_to_bid32=uninstrumented fun:__binary128_to_bid64=uninstrumented fun:__binary32_to_bid128=uninstrumented fun:__binary32_to_bid32=uninstrumented fun:__binary32_to_bid64=uninstrumented fun:__binary64_to_bid128=uninstrumented fun:__binary64_to_bid32=uninstrumented fun:__binary64_to_bid64=uninstrumented fun:__binary80_to_bid128=uninstrumented fun:__binary80_to_bid32=uninstrumented fun:__binary80_to_bid64=uninstrumented fun:__bsd_getpgrp=uninstrumented fun:__bswapdi2=uninstrumented fun:__bswapsi2=uninstrumented fun:__bzero=uninstrumented fun:__call_tls_dtors=uninstrumented fun:__chk_fail=uninstrumented fun:__clear_cache=uninstrumented fun:__clock_getcpuclockid=uninstrumented fun:__clock_getres=uninstrumented fun:__clock_gettime=uninstrumented fun:__clock_nanosleep=uninstrumented fun:__clock_settime=uninstrumented fun:__clog10=uninstrumented fun:__clog10f=uninstrumented fun:__clog10l=uninstrumented fun:__clone=uninstrumented fun:__close=uninstrumented fun:__close_nocancel=uninstrumented fun:__clrsbdi2=uninstrumented fun:__clrsbti2=uninstrumented fun:__clzdi2=uninstrumented fun:__clzti2=uninstrumented fun:__cmpti2=uninstrumented fun:__cmsg_nxthdr=uninstrumented fun:__confstr_chk=uninstrumented fun:__connect=uninstrumented fun:__copy_grp=uninstrumented fun:__cosh_finite=uninstrumented fun:__coshf128_finite=uninstrumented fun:__coshf_finite=uninstrumented fun:__coshl_finite=uninstrumented fun:__cpu_indicator_init=uninstrumented fun:__create_ib_request=uninstrumented fun:__ctype_b_loc=uninstrumented fun:__ctype_get_mb_cur_max=uninstrumented fun:__ctype_init=uninstrumented fun:__ctype_tolower_loc=uninstrumented fun:__ctype_toupper_loc=uninstrumented fun:__ctzdi2=uninstrumented fun:__ctzti2=uninstrumented fun:__cxa_at_quick_exit=uninstrumented fun:__cxa_atexit=uninstrumented fun:__cxa_finalize=uninstrumented fun:__cxa_thread_atexit_impl=uninstrumented fun:__cyg_profile_func_enter=uninstrumented fun:__cyg_profile_func_exit=uninstrumented fun:__dcgettext=uninstrumented fun:__default_morecore=uninstrumented fun:__deregister_frame=uninstrumented fun:__deregister_frame_info=uninstrumented fun:__deregister_frame_info_bases=uninstrumented fun:__dfp_clear_except=uninstrumented fun:__dfp_get_round=uninstrumented fun:__dfp_raise_except=uninstrumented fun:__dfp_set_round=uninstrumented fun:__dfp_test_except=uninstrumented fun:__dgettext=uninstrumented fun:__divdc3=uninstrumented fun:__divmodti4=uninstrumented fun:__divsc3=uninstrumented fun:__divtc3=uninstrumented fun:__divtf3=uninstrumented fun:__divti3=uninstrumented fun:__divxc3=uninstrumented fun:__dn_comp=uninstrumented fun:__dn_count_labels=uninstrumented fun:__dn_expand=uninstrumented fun:__dn_skipname=uninstrumented fun:__do_niscall3=uninstrumented fun:__dprintf_chk=uninstrumented fun:__dup2=uninstrumented fun:__duplocale=uninstrumented fun:__emutls_get_address=uninstrumented fun:__emutls_register_common=uninstrumented fun:__enable_execute_stack=uninstrumented fun:__endmntent=uninstrumented fun:__eprintf=uninstrumented fun:__eqtf2=uninstrumented fun:__errno_location=uninstrumented fun:__exp10_finite=uninstrumented fun:__exp10f128_finite=uninstrumented fun:__exp10f_finite=uninstrumented fun:__exp10l_finite=uninstrumented fun:__exp2_finite=uninstrumented fun:__exp2f128_finite=uninstrumented fun:__exp2f_finite=uninstrumented fun:__exp2l_finite=uninstrumented fun:__exp_finite=uninstrumented fun:__expf128_finite=uninstrumented fun:__expf_finite=uninstrumented fun:__expl_finite=uninstrumented fun:__explicit_bzero_chk=uninstrumented fun:__extenddftf2=uninstrumented fun:__extendsftf2=uninstrumented fun:__extendxftf2=uninstrumented fun:__fbufsize=uninstrumented fun:__fcntl=uninstrumented fun:__fdelt_chk=uninstrumented fun:__fdelt_warn=uninstrumented fun:__fentry__=uninstrumented fun:__ffs=uninstrumented fun:__ffsdi2=uninstrumented fun:__ffsti2=uninstrumented fun:__fgets_chk=uninstrumented fun:__fgets_unlocked_chk=uninstrumented fun:__fgetws_chk=uninstrumented fun:__fgetws_unlocked_chk=uninstrumented fun:__finite=uninstrumented fun:__finitef=uninstrumented fun:__finitef128=uninstrumented fun:__finitel=uninstrumented fun:__fixdfti=uninstrumented fun:__fixsfti=uninstrumented fun:__fixtfdi=uninstrumented fun:__fixtfsi=uninstrumented fun:__fixtfti=uninstrumented fun:__fixunsdfdi=uninstrumented fun:__fixunsdfti=uninstrumented fun:__fixunssfdi=uninstrumented fun:__fixunssfti=uninstrumented fun:__fixunstfdi=uninstrumented fun:__fixunstfsi=uninstrumented fun:__fixunstfti=uninstrumented fun:__fixunsxfdi=uninstrumented fun:__fixunsxfti=uninstrumented fun:__fixxfti=uninstrumented fun:__flbf=uninstrumented fun:__floatditf=uninstrumented fun:__floatsitf=uninstrumented fun:__floattidf=uninstrumented fun:__floattisf=uninstrumented fun:__floattitf=uninstrumented fun:__floattixf=uninstrumented fun:__floatunditf=uninstrumented fun:__floatunsitf=uninstrumented fun:__floatuntidf=uninstrumented fun:__floatuntisf=uninstrumented fun:__floatuntitf=uninstrumented fun:__floatuntixf=uninstrumented fun:__fmod_finite=uninstrumented fun:__fmodf128_finite=uninstrumented fun:__fmodf_finite=uninstrumented fun:__fmodl_finite=uninstrumented fun:__follow_path=uninstrumented fun:__fork=uninstrumented fun:__fortify_fail=uninstrumented fun:__fp_nquery=uninstrumented fun:__fp_query=uninstrumented fun:__fp_resstat=uninstrumented fun:__fpclassify=uninstrumented fun:__fpclassifyf=uninstrumented fun:__fpclassifyf128=uninstrumented fun:__fpclassifyl=uninstrumented fun:__fpending=uninstrumented fun:__fprintf_chk=uninstrumented fun:__fpurge=uninstrumented fun:__fread_chk=uninstrumented fun:__fread_unlocked_chk=uninstrumented fun:__freadable=uninstrumented fun:__freading=uninstrumented fun:__free_fdresult=uninstrumented fun:__freelocale=uninstrumented fun:__fsetlocking=uninstrumented fun:__fstat=uninstrumented fun:__fwprintf_chk=uninstrumented fun:__fwritable=uninstrumented fun:__fwriting=uninstrumented fun:__fxstat=uninstrumented fun:__fxstat64=uninstrumented fun:__fxstatat=uninstrumented fun:__fxstatat64=uninstrumented fun:__gai_sigqueue=uninstrumented fun:__gamma_r_finite=uninstrumented fun:__gammaf128_r_finite=uninstrumented fun:__gammaf_r_finite=uninstrumented fun:__gammal_r_finite=uninstrumented fun:__gcc_bcmp=uninstrumented fun:__gcc_personality_v0=uninstrumented fun:__gconv_get_alias_db=uninstrumented fun:__gconv_get_cache=uninstrumented fun:__gconv_get_modules_db=uninstrumented fun:__gconv_transliterate=uninstrumented fun:__generic_findstack=uninstrumented fun:__generic_morestack=uninstrumented fun:__generic_morestack_set_initial_sp=uninstrumented fun:__generic_releasestack=uninstrumented fun:__get_cpu_features=uninstrumented fun:__getauxval=uninstrumented fun:__getcwd_chk=uninstrumented fun:__getdelim=uninstrumented fun:__getdomainname_chk=uninstrumented fun:__getf2=uninstrumented fun:__getgroups_chk=uninstrumented fun:__gethostname_chk=uninstrumented fun:__getlogin_r_chk=uninstrumented fun:__getmntent_r=uninstrumented fun:__getpagesize=uninstrumented fun:__getpgid=uninstrumented fun:__getpid=uninstrumented fun:__getrlimit=uninstrumented fun:__gets_chk=uninstrumented fun:__gettimeofday=uninstrumented fun:__getwd_chk=uninstrumented fun:__gmtime_r=uninstrumented fun:__gttf2=uninstrumented fun:__h_errno_location=uninstrumented fun:__hostalias=uninstrumented fun:__hypot_finite=uninstrumented fun:__hypotf128_finite=uninstrumented fun:__hypotf_finite=uninstrumented fun:__hypotl_finite=uninstrumented fun:__inet6_scopeid_pton=uninstrumented fun:__inet_pton_length=uninstrumented fun:__internal_endnetgrent=uninstrumented fun:__internal_getnetgrent_r=uninstrumented fun:__internal_setnetgrent=uninstrumented fun:__isalnum_l=uninstrumented fun:__isalpha_l=uninstrumented fun:__isascii_l=uninstrumented fun:__isblank_l=uninstrumented fun:__iscanonicall=uninstrumented fun:__iscntrl_l=uninstrumented fun:__isctype=uninstrumented fun:__isdigit_l=uninstrumented fun:__iseqsig=uninstrumented fun:__iseqsigf=uninstrumented fun:__iseqsigf128=uninstrumented fun:__iseqsigl=uninstrumented fun:__isgraph_l=uninstrumented fun:__isinf=uninstrumented fun:__isinff=uninstrumented fun:__isinff128=uninstrumented fun:__isinfl=uninstrumented fun:__islower_l=uninstrumented fun:__isnan=uninstrumented fun:__isnanf=uninstrumented fun:__isnanf128=uninstrumented fun:__isnanl=uninstrumented fun:__isoc99_fscanf=uninstrumented fun:__isoc99_fwscanf=uninstrumented fun:__isoc99_scanf=uninstrumented fun:__isoc99_sscanf=uninstrumented fun:__isoc99_swscanf=uninstrumented fun:__isoc99_vfscanf=uninstrumented fun:__isoc99_vfwscanf=uninstrumented fun:__isoc99_vscanf=uninstrumented fun:__isoc99_vsscanf=uninstrumented fun:__isoc99_vswscanf=uninstrumented fun:__isoc99_vwscanf=uninstrumented fun:__isoc99_wscanf=uninstrumented fun:__isprint_l=uninstrumented fun:__ispunct_l=uninstrumented fun:__issignaling=uninstrumented fun:__issignalingf=uninstrumented fun:__issignalingf128=uninstrumented fun:__issignalingl=uninstrumented fun:__isspace_l=uninstrumented fun:__isupper_l=uninstrumented fun:__iswalnum_l=uninstrumented fun:__iswalpha_l=uninstrumented fun:__iswblank_l=uninstrumented fun:__iswcntrl_l=uninstrumented fun:__iswctype=uninstrumented fun:__iswctype_l=uninstrumented fun:__iswdigit_l=uninstrumented fun:__iswgraph_l=uninstrumented fun:__iswlower_l=uninstrumented fun:__iswprint_l=uninstrumented fun:__iswpunct_l=uninstrumented fun:__iswspace_l=uninstrumented fun:__iswupper_l=uninstrumented fun:__iswxdigit_l=uninstrumented fun:__isxdigit_l=uninstrumented fun:__ivaliduser=uninstrumented fun:__j0_finite=uninstrumented fun:__j0f128_finite=uninstrumented fun:__j0f_finite=uninstrumented fun:__j0l_finite=uninstrumented fun:__j1_finite=uninstrumented fun:__j1f128_finite=uninstrumented fun:__j1f_finite=uninstrumented fun:__j1l_finite=uninstrumented fun:__jn_finite=uninstrumented fun:__jnf128_finite=uninstrumented fun:__jnf_finite=uninstrumented fun:__jnl_finite=uninstrumented fun:__letf2=uninstrumented fun:__lgamma_r_finite=uninstrumented fun:__lgammaf128_r_finite=uninstrumented fun:__lgammaf_r_finite=uninstrumented fun:__lgammal_r_finite=uninstrumented fun:__libc_alloc_buffer_alloc_array=uninstrumented fun:__libc_alloc_buffer_allocate=uninstrumented fun:__libc_alloc_buffer_copy_bytes=uninstrumented fun:__libc_alloc_buffer_copy_string=uninstrumented fun:__libc_alloc_buffer_create_failure=uninstrumented fun:__libc_alloca_cutoff=uninstrumented fun:__libc_allocate_rtsig=uninstrumented fun:__libc_allocate_rtsig_private=uninstrumented fun:__libc_calloc=uninstrumented fun:__libc_clntudp_bufcreate=uninstrumented fun:__libc_csu_fini=uninstrumented fun:__libc_csu_init=uninstrumented fun:__libc_current_sigrtmax=uninstrumented fun:__libc_current_sigrtmax_private=uninstrumented fun:__libc_current_sigrtmin=uninstrumented fun:__libc_current_sigrtmin_private=uninstrumented fun:__libc_dlclose=uninstrumented fun:__libc_dlopen_mode=uninstrumented fun:__libc_dlsym=uninstrumented fun:__libc_dlvsym=uninstrumented fun:__libc_dynarray_at_failure=uninstrumented fun:__libc_dynarray_emplace_enlarge=uninstrumented fun:__libc_dynarray_finalize=uninstrumented fun:__libc_dynarray_resize=uninstrumented fun:__libc_dynarray_resize_clear=uninstrumented fun:__libc_fatal=uninstrumented fun:__libc_fork=uninstrumented fun:__libc_free=uninstrumented fun:__libc_freeres=uninstrumented fun:__libc_ifunc_impl_list=uninstrumented fun:__libc_init_first=uninstrumented fun:__libc_longjmp=uninstrumented fun:__libc_mallinfo=uninstrumented fun:__libc_malloc=uninstrumented fun:__libc_mallopt=uninstrumented fun:__libc_memalign=uninstrumented fun:__libc_msgrcv=uninstrumented fun:__libc_msgsnd=uninstrumented fun:__libc_pread=uninstrumented fun:__libc_pthread_init=uninstrumented fun:__libc_pvalloc=uninstrumented fun:__libc_pwrite=uninstrumented fun:__libc_realloc=uninstrumented fun:__libc_reallocarray=uninstrumented fun:__libc_rpc_getport=uninstrumented fun:__libc_sa_len=uninstrumented fun:__libc_scratch_buffer_grow=uninstrumented fun:__libc_scratch_buffer_grow_preserve=uninstrumented fun:__libc_scratch_buffer_set_array_size=uninstrumented fun:__libc_secure_getenv=uninstrumented fun:__libc_siglongjmp=uninstrumented fun:__libc_start_main=uninstrumented fun:__libc_system=uninstrumented fun:__libc_thread_freeres=uninstrumented fun:__libc_valloc=uninstrumented fun:__libc_vfork=uninstrumented fun:__loc_aton=uninstrumented fun:__loc_ntoa=uninstrumented fun:__log10_finite=uninstrumented fun:__log10f128_finite=uninstrumented fun:__log10f_finite=uninstrumented fun:__log10l_finite=uninstrumented fun:__log2_finite=uninstrumented fun:__log2f128_finite=uninstrumented fun:__log2f_finite=uninstrumented fun:__log2l_finite=uninstrumented fun:__log_finite=uninstrumented fun:__logf128_finite=uninstrumented fun:__logf_finite=uninstrumented fun:__logl_finite=uninstrumented fun:__longjmp_chk=uninstrumented fun:__lseek=uninstrumented fun:__lshrti3=uninstrumented fun:__lstat=uninstrumented fun:__lttf2=uninstrumented fun:__lxstat=uninstrumented fun:__lxstat64=uninstrumented fun:__madvise=uninstrumented fun:__mbrlen=uninstrumented fun:__mbrtowc=uninstrumented fun:__mbsnrtowcs_chk=uninstrumented fun:__mbsrtowcs_chk=uninstrumented fun:__mbstowcs_chk=uninstrumented fun:__memcpy_chk=uninstrumented fun:__memmove_chk=uninstrumented fun:__mempcpy=uninstrumented fun:__mempcpy_chk=uninstrumented fun:__mempcpy_small=uninstrumented fun:__memset_chk=uninstrumented fun:__merge_grp=uninstrumented fun:__mknod=uninstrumented fun:__mktemp=uninstrumented fun:__mmap=uninstrumented fun:__modti3=uninstrumented fun:__monstartup=uninstrumented fun:__morestack=uninstrumented fun:__morestack_allocate_stack_space=uninstrumented fun:__morestack_block_signals=uninstrumented fun:__morestack_fail=uninstrumented fun:__morestack_get_guard=uninstrumented fun:__morestack_large_model=uninstrumented fun:__morestack_load_mmap=uninstrumented fun:__morestack_make_guard=uninstrumented fun:__morestack_non_split=uninstrumented fun:__morestack_release_segments=uninstrumented fun:__morestack_set_guard=uninstrumented fun:__morestack_unblock_signals=uninstrumented fun:__mprotect=uninstrumented fun:__mq_open_2=uninstrumented fun:__muldc3=uninstrumented fun:__mulsc3=uninstrumented fun:__multc3=uninstrumented fun:__multf3=uninstrumented fun:__multi3=uninstrumented fun:__mulvdi3=uninstrumented fun:__mulvsi3=uninstrumented fun:__mulvti3=uninstrumented fun:__mulxc3=uninstrumented fun:__munmap=uninstrumented fun:__nanosleep=uninstrumented fun:__negtf2=uninstrumented fun:__negti2=uninstrumented fun:__negvdi2=uninstrumented fun:__negvsi2=uninstrumented fun:__negvti2=uninstrumented fun:__netf2=uninstrumented fun:__netlink_assert_response=uninstrumented fun:__newlocale=uninstrumented fun:__nis_default_access=uninstrumented fun:__nis_default_group=uninstrumented fun:__nis_default_owner=uninstrumented fun:__nis_default_ttl=uninstrumented fun:__nis_finddirectory=uninstrumented fun:__nis_hash=uninstrumented fun:__nisbind_connect=uninstrumented fun:__nisbind_create=uninstrumented fun:__nisbind_destroy=uninstrumented fun:__nisbind_next=uninstrumented fun:__nl_langinfo_l=uninstrumented fun:__ns_get16=uninstrumented fun:__ns_get32=uninstrumented fun:__ns_name_ntop=uninstrumented fun:__ns_name_unpack=uninstrumented fun:__nss_configure_lookup=uninstrumented fun:__nss_database_lookup=uninstrumented fun:__nss_disable_nscd=uninstrumented fun:__nss_group_lookup=uninstrumented fun:__nss_group_lookup2=uninstrumented fun:__nss_hash=uninstrumented fun:__nss_hostname_digits_dots=uninstrumented fun:__nss_hosts_lookup=uninstrumented fun:__nss_hosts_lookup2=uninstrumented fun:__nss_lookup=uninstrumented fun:__nss_lookup_function=uninstrumented fun:__nss_next=uninstrumented fun:__nss_next2=uninstrumented fun:__nss_passwd_lookup=uninstrumented fun:__nss_passwd_lookup2=uninstrumented fun:__nss_services_lookup2=uninstrumented fun:__obstack_printf_chk=uninstrumented fun:__obstack_vprintf_chk=uninstrumented fun:__open=uninstrumented fun:__open64=uninstrumented fun:__open64_2=uninstrumented fun:__open_2=uninstrumented fun:__open_catalog=uninstrumented fun:__open_nocancel=uninstrumented fun:__openat64_2=uninstrumented fun:__openat_2=uninstrumented fun:__overflow=uninstrumented fun:__p_cdname=uninstrumented fun:__p_cdnname=uninstrumented fun:__p_class=uninstrumented fun:__p_fqname=uninstrumented fun:__p_fqnname=uninstrumented fun:__p_option=uninstrumented fun:__p_query=uninstrumented fun:__p_rcode=uninstrumented fun:__p_secstodate=uninstrumented fun:__p_time=uninstrumented fun:__p_type=uninstrumented fun:__paritydi2=uninstrumented fun:__parityti2=uninstrumented fun:__pipe=uninstrumented fun:__poll=uninstrumented fun:__poll_chk=uninstrumented fun:__popcountdi2=uninstrumented fun:__popcountti2=uninstrumented fun:__posix_getopt=uninstrumented fun:__pow_finite=uninstrumented fun:__powf128_finite=uninstrumented fun:__powf_finite=uninstrumented fun:__powidf2=uninstrumented fun:__powisf2=uninstrumented fun:__powitf2=uninstrumented fun:__powixf2=uninstrumented fun:__powl_finite=uninstrumented fun:__ppoll_chk=uninstrumented fun:__pread64=uninstrumented fun:__pread64_chk=uninstrumented fun:__pread_chk=uninstrumented fun:__prepare_niscall=uninstrumented fun:__printf_chk=uninstrumented fun:__printf_fp=uninstrumented fun:__profile_frequency=uninstrumented fun:__pthread_atfork=uninstrumented fun:__pthread_barrier_init=uninstrumented fun:__pthread_barrier_wait=uninstrumented fun:__pthread_cleanup_routine=uninstrumented fun:__pthread_clock_gettime=uninstrumented fun:__pthread_clock_settime=uninstrumented fun:__pthread_get_minstack=uninstrumented fun:__pthread_getspecific=uninstrumented fun:__pthread_initialize_minimal=uninstrumented fun:__pthread_key_create=uninstrumented fun:__pthread_mutex_destroy=uninstrumented fun:__pthread_mutex_init=uninstrumented fun:__pthread_mutex_lock=uninstrumented fun:__pthread_mutex_trylock=uninstrumented fun:__pthread_mutex_unlock=uninstrumented fun:__pthread_mutexattr_destroy=uninstrumented fun:__pthread_mutexattr_init=uninstrumented fun:__pthread_mutexattr_settype=uninstrumented fun:__pthread_once=uninstrumented fun:__pthread_register_cancel=uninstrumented fun:__pthread_register_cancel_defer=uninstrumented fun:__pthread_rwlock_destroy=uninstrumented fun:__pthread_rwlock_init=uninstrumented fun:__pthread_rwlock_rdlock=uninstrumented fun:__pthread_rwlock_tryrdlock=uninstrumented fun:__pthread_rwlock_trywrlock=uninstrumented fun:__pthread_rwlock_unlock=uninstrumented fun:__pthread_rwlock_wrlock=uninstrumented fun:__pthread_setspecific=uninstrumented fun:__pthread_unregister_cancel=uninstrumented fun:__pthread_unregister_cancel_restore=uninstrumented fun:__pthread_unwind=uninstrumented fun:__pthread_unwind_next=uninstrumented fun:__ptsname_r_chk=uninstrumented fun:__putlong=uninstrumented fun:__putshort=uninstrumented fun:__pwrite64=uninstrumented fun:__rawmemchr=uninstrumented fun:__read=uninstrumented fun:__read_chk=uninstrumented fun:__read_nocancel=uninstrumented fun:__readlink_chk=uninstrumented fun:__readlinkat_chk=uninstrumented fun:__realpath_chk=uninstrumented fun:__recv=uninstrumented fun:__recv_chk=uninstrumented fun:__recvfrom_chk=uninstrumented fun:__register_atfork=uninstrumented fun:__register_frame=uninstrumented fun:__register_frame_info=uninstrumented fun:__register_frame_info_bases=uninstrumented fun:__register_frame_info_table=uninstrumented fun:__register_frame_info_table_bases=uninstrumented fun:__register_frame_table=uninstrumented fun:__remainder_finite=uninstrumented fun:__remainderf128_finite=uninstrumented fun:__remainderf_finite=uninstrumented fun:__remainderl_finite=uninstrumented fun:__res_close=uninstrumented fun:__res_context_hostalias=uninstrumented fun:__res_context_query=uninstrumented fun:__res_context_search=uninstrumented fun:__res_dnok=uninstrumented fun:__res_hnok=uninstrumented fun:__res_hostalias=uninstrumented fun:__res_iclose=uninstrumented fun:__res_init=uninstrumented fun:__res_isourserver=uninstrumented fun:__res_mailok=uninstrumented fun:__res_mkquery=uninstrumented fun:__res_nameinquery=uninstrumented fun:__res_nclose=uninstrumented fun:__res_ninit=uninstrumented fun:__res_nmkquery=uninstrumented fun:__res_nquery=uninstrumented fun:__res_nquerydomain=uninstrumented fun:__res_nsearch=uninstrumented fun:__res_nsend=uninstrumented fun:__res_ownok=uninstrumented fun:__res_queriesmatch=uninstrumented fun:__res_query=uninstrumented fun:__res_querydomain=uninstrumented fun:__res_randomid=uninstrumented fun:__res_search=uninstrumented fun:__res_send=uninstrumented fun:__res_state=uninstrumented fun:__resolv_context_get=uninstrumented fun:__resolv_context_get_override=uninstrumented fun:__resolv_context_get_preinit=uninstrumented fun:__resolv_context_put=uninstrumented fun:__rpc_thread_createerr=uninstrumented fun:__rpc_thread_svc_fdset=uninstrumented fun:__rpc_thread_svc_max_pollfd=uninstrumented fun:__rpc_thread_svc_pollfd=uninstrumented fun:__sbrk=uninstrumented fun:__scalb_finite=uninstrumented fun:__scalbf_finite=uninstrumented fun:__scalbl_finite=uninstrumented fun:__sched_cpualloc=uninstrumented fun:__sched_cpucount=uninstrumented fun:__sched_cpufree=uninstrumented fun:__sched_get_priority_max=uninstrumented fun:__sched_get_priority_min=uninstrumented fun:__sched_getparam=uninstrumented fun:__sched_getscheduler=uninstrumented fun:__sched_setscheduler=uninstrumented fun:__sched_yield=uninstrumented fun:__secure_getenv=uninstrumented fun:__select=uninstrumented fun:__send=uninstrumented fun:__sendmmsg=uninstrumented fun:__setmntent=uninstrumented fun:__setpgid=uninstrumented fun:__sfp_handle_exceptions=uninstrumented fun:__shm_directory=uninstrumented fun:__sigaction=uninstrumented fun:__sigaddset=uninstrumented fun:__sigdelset=uninstrumented fun:__sigismember=uninstrumented fun:__signbit=uninstrumented fun:__signbitf=uninstrumented fun:__signbitf128=uninstrumented fun:__signbitl=uninstrumented fun:__sigpause=uninstrumented fun:__sigsetjmp=uninstrumented fun:__sigsuspend=uninstrumented fun:__sigtimedwait=uninstrumented fun:__sinh_finite=uninstrumented fun:__sinhf128_finite=uninstrumented fun:__sinhf_finite=uninstrumented fun:__sinhl_finite=uninstrumented fun:__snprintf=uninstrumented fun:__snprintf_chk=uninstrumented fun:__socket=uninstrumented fun:__splitstack_block_signals=uninstrumented fun:__splitstack_block_signals_context=uninstrumented fun:__splitstack_find=uninstrumented fun:__splitstack_find_context=uninstrumented fun:__splitstack_getcontext=uninstrumented fun:__splitstack_makecontext=uninstrumented fun:__splitstack_releasecontext=uninstrumented fun:__splitstack_resetcontext=uninstrumented fun:__splitstack_setcontext=uninstrumented fun:__sprintf_chk=uninstrumented fun:__sqrt_finite=uninstrumented fun:__sqrtf128_finite=uninstrumented fun:__sqrtf_finite=uninstrumented fun:__sqrtl_finite=uninstrumented fun:__stack_chk_fail=uninstrumented fun:__stack_chk_fail_local=uninstrumented fun:__stack_split_initialize=uninstrumented fun:__stat=uninstrumented fun:__statfs=uninstrumented fun:__stpcpy=uninstrumented fun:__stpcpy_chk=uninstrumented fun:__stpcpy_small=uninstrumented fun:__stpncpy=uninstrumented fun:__stpncpy_chk=uninstrumented fun:__strcasecmp=uninstrumented fun:__strcasecmp_l=uninstrumented fun:__strcasestr=uninstrumented fun:__strcat_chk=uninstrumented fun:__strcoll_l=uninstrumented fun:__strcpy_chk=uninstrumented fun:__strcpy_small=uninstrumented fun:__strcspn_c1=uninstrumented fun:__strcspn_c2=uninstrumented fun:__strcspn_c3=uninstrumented fun:__strdup=uninstrumented fun:__strerror_r=uninstrumented fun:__strfmon_l=uninstrumented fun:__strftime_l=uninstrumented fun:__strncasecmp_l=uninstrumented fun:__strncat_chk=uninstrumented fun:__strncpy_chk=uninstrumented fun:__strndup=uninstrumented fun:__strpbrk_c2=uninstrumented fun:__strpbrk_c3=uninstrumented fun:__strsep_1c=uninstrumented fun:__strsep_2c=uninstrumented fun:__strsep_3c=uninstrumented fun:__strsep_g=uninstrumented fun:__strspn_c1=uninstrumented fun:__strspn_c2=uninstrumented fun:__strspn_c3=uninstrumented fun:__strtod_internal=uninstrumented fun:__strtod_l=uninstrumented fun:__strtod_nan=uninstrumented fun:__strtof128_internal=uninstrumented fun:__strtof128_nan=uninstrumented fun:__strtof_internal=uninstrumented fun:__strtof_l=uninstrumented fun:__strtof_nan=uninstrumented fun:__strtok_r=uninstrumented fun:__strtok_r_1c=uninstrumented fun:__strtol_internal=uninstrumented fun:__strtol_l=uninstrumented fun:__strtold_internal=uninstrumented fun:__strtold_l=uninstrumented fun:__strtold_nan=uninstrumented fun:__strtoll_internal=uninstrumented fun:__strtoll_l=uninstrumented fun:__strtoul_internal=uninstrumented fun:__strtoul_l=uninstrumented fun:__strtoull_internal=uninstrumented fun:__strtoull_l=uninstrumented fun:__strverscmp=uninstrumented fun:__strxfrm_l=uninstrumented fun:__subtf3=uninstrumented fun:__subvdi3=uninstrumented fun:__subvsi3=uninstrumented fun:__subvti3=uninstrumented fun:__swprintf_chk=uninstrumented fun:__sym_ntop=uninstrumented fun:__sym_ntos=uninstrumented fun:__sym_ston=uninstrumented fun:__sysconf=uninstrumented fun:__sysctl=uninstrumented fun:__syslog_chk=uninstrumented fun:__sysv_signal=uninstrumented fun:__tdelete=uninstrumented fun:__tfind=uninstrumented fun:__tls_get_addr=uninstrumented fun:__toascii_l=uninstrumented fun:__tolower_l=uninstrumented fun:__toupper_l=uninstrumented fun:__towctrans=uninstrumented fun:__towctrans_l=uninstrumented fun:__towlower_l=uninstrumented fun:__towupper_l=uninstrumented fun:__trunctfdf2=uninstrumented fun:__trunctfsf2=uninstrumented fun:__trunctfxf2=uninstrumented fun:__tsearch=uninstrumented fun:__ttyname_r_chk=uninstrumented fun:__tunable_get_val=uninstrumented fun:__twalk=uninstrumented fun:__ucmpti2=uninstrumented fun:__udiv_w_sdiv=uninstrumented fun:__udivmodti4=uninstrumented fun:__udivti3=uninstrumented fun:__uflow=uninstrumented fun:__umodti3=uninstrumented fun:__underflow=uninstrumented fun:__unordtf2=uninstrumented fun:__uselocale=uninstrumented fun:__vasprintf_chk=uninstrumented fun:__vdprintf_chk=uninstrumented fun:__vfork=uninstrumented fun:__vfprintf_chk=uninstrumented fun:__vfscanf=uninstrumented fun:__vfwprintf_chk=uninstrumented fun:__vprintf_chk=uninstrumented fun:__vsnprintf=uninstrumented fun:__vsnprintf_chk=uninstrumented fun:__vsprintf_chk=uninstrumented fun:__vsscanf=uninstrumented fun:__vswprintf_chk=uninstrumented fun:__vsyslog_chk=uninstrumented fun:__vwprintf_chk=uninstrumented fun:__wait=uninstrumented fun:__waitpid=uninstrumented fun:__wcpcpy_chk=uninstrumented fun:__wcpncpy_chk=uninstrumented fun:__wcrtomb_chk=uninstrumented fun:__wcscasecmp_l=uninstrumented fun:__wcscat_chk=uninstrumented fun:__wcscoll_l=uninstrumented fun:__wcscpy_chk=uninstrumented fun:__wcsftime_l=uninstrumented fun:__wcsncasecmp_l=uninstrumented fun:__wcsncat_chk=uninstrumented fun:__wcsncpy_chk=uninstrumented fun:__wcsnrtombs_chk=uninstrumented fun:__wcsrtombs_chk=uninstrumented fun:__wcstod_internal=uninstrumented fun:__wcstod_l=uninstrumented fun:__wcstof128_internal=uninstrumented fun:__wcstof_internal=uninstrumented fun:__wcstof_l=uninstrumented fun:__wcstol_internal=uninstrumented fun:__wcstol_l=uninstrumented fun:__wcstold_internal=uninstrumented fun:__wcstold_l=uninstrumented fun:__wcstoll_internal=uninstrumented fun:__wcstoll_l=uninstrumented fun:__wcstombs_chk=uninstrumented fun:__wcstoul_internal=uninstrumented fun:__wcstoul_l=uninstrumented fun:__wcstoull_internal=uninstrumented fun:__wcstoull_l=uninstrumented fun:__wcsxfrm_l=uninstrumented fun:__wctomb_chk=uninstrumented fun:__wctrans_l=uninstrumented fun:__wctype_l=uninstrumented fun:__wmemcpy_chk=uninstrumented fun:__wmemmove_chk=uninstrumented fun:__wmempcpy_chk=uninstrumented fun:__wmemset_chk=uninstrumented fun:__woverflow=uninstrumented fun:__wprintf_chk=uninstrumented fun:__wrap_pthread_create=uninstrumented fun:__write=uninstrumented fun:__wuflow=uninstrumented fun:__wunderflow=uninstrumented fun:__xmknod=uninstrumented fun:__xmknodat=uninstrumented fun:__xpg_basename=uninstrumented fun:__xpg_sigpause=uninstrumented fun:__xpg_strerror_r=uninstrumented fun:__xstat=uninstrumented fun:__xstat64=uninstrumented fun:__y0_finite=uninstrumented fun:__y0f128_finite=uninstrumented fun:__y0f_finite=uninstrumented fun:__y0l_finite=uninstrumented fun:__y1_finite=uninstrumented fun:__y1f128_finite=uninstrumented fun:__y1f_finite=uninstrumented fun:__y1l_finite=uninstrumented fun:__yn_finite=uninstrumented fun:__ynf128_finite=uninstrumented fun:__ynf_finite=uninstrumented fun:__ynl_finite=uninstrumented fun:__yp_check=uninstrumented fun:_authenticate=uninstrumented fun:_dl_addr=uninstrumented fun:_dl_allocate_tls=uninstrumented fun:_dl_allocate_tls_init=uninstrumented fun:_dl_catch_error=uninstrumented fun:_dl_catch_exception=uninstrumented fun:_dl_deallocate_tls=uninstrumented fun:_dl_debug_state=uninstrumented fun:_dl_exception_create=uninstrumented fun:_dl_exception_create_format=uninstrumented fun:_dl_exception_free=uninstrumented fun:_dl_find_dso_for_object=uninstrumented fun:_dl_get_tls_static_info=uninstrumented fun:_dl_make_stack_executable=uninstrumented fun:_dl_mcount=uninstrumented fun:_dl_mcount_wrapper=uninstrumented fun:_dl_mcount_wrapper_check=uninstrumented fun:_dl_rtld_di_serinfo=uninstrumented fun:_dl_signal_error=uninstrumented fun:_dl_signal_exception=uninstrumented fun:_dl_sym=uninstrumented fun:_dl_vsym=uninstrumented fun:_exit=uninstrumented fun:_flushlbf=uninstrumented fun:_gethtbyaddr=uninstrumented fun:_gethtbyname=uninstrumented fun:_gethtbyname2=uninstrumented fun:_gethtent=uninstrumented fun:_getlong=uninstrumented fun:_getshort=uninstrumented fun:_longjmp=uninstrumented fun:_mcleanup=uninstrumented fun:_mcount=uninstrumented fun:_nsl_default_nss=uninstrumented fun:_nss_files_parse_grent=uninstrumented fun:_nss_files_parse_pwent=uninstrumented fun:_nss_files_parse_sgent=uninstrumented fun:_nss_files_parse_spent=uninstrumented fun:_obstack_allocated_p=uninstrumented fun:_obstack_begin=uninstrumented fun:_obstack_begin_1=uninstrumented fun:_obstack_free=uninstrumented fun:_obstack_memory_used=uninstrumented fun:_obstack_newchunk=uninstrumented fun:_pthread_cleanup_pop=uninstrumented fun:_pthread_cleanup_pop_restore=uninstrumented fun:_pthread_cleanup_push=uninstrumented fun:_pthread_cleanup_push_defer=uninstrumented fun:_rpc_dtablesize=uninstrumented fun:_seterr_reply=uninstrumented fun:_sethtent=uninstrumented fun:_setjmp=uninstrumented fun:_tolower=uninstrumented fun:_toupper=uninstrumented fun:_xdr_ib_request=uninstrumented fun:_xdr_nis_result=uninstrumented fun:a64l=uninstrumented fun:abort=uninstrumented fun:abs=uninstrumented fun:accept=uninstrumented fun:accept4=uninstrumented fun:access=uninstrumented fun:acct=uninstrumented fun:acos=uninstrumented fun:acosf=uninstrumented fun:acosf128=uninstrumented fun:acosf32=uninstrumented fun:acosf32x=uninstrumented fun:acosf64=uninstrumented fun:acosf64x=uninstrumented fun:acosh=uninstrumented fun:acoshf=uninstrumented fun:acoshf128=uninstrumented fun:acoshf32=uninstrumented fun:acoshf32x=uninstrumented fun:acoshf64=uninstrumented fun:acoshf64x=uninstrumented fun:acoshl=uninstrumented fun:acosl=uninstrumented fun:addmntent=uninstrumented fun:addseverity=uninstrumented fun:adjtime=uninstrumented fun:adjtimex=uninstrumented fun:advance=uninstrumented fun:aio_cancel=uninstrumented fun:aio_cancel64=uninstrumented fun:aio_error=uninstrumented fun:aio_error64=uninstrumented fun:aio_fsync=uninstrumented fun:aio_fsync64=uninstrumented fun:aio_init=uninstrumented fun:aio_read=uninstrumented fun:aio_read64=uninstrumented fun:aio_return=uninstrumented fun:aio_return64=uninstrumented fun:aio_suspend=uninstrumented fun:aio_suspend64=uninstrumented fun:aio_write=uninstrumented fun:aio_write64=uninstrumented fun:alarm=uninstrumented fun:aligned_alloc=uninstrumented fun:alphasort=uninstrumented fun:alphasort64=uninstrumented fun:arch_prctl=uninstrumented fun:argp_error=uninstrumented fun:argp_failure=uninstrumented fun:argp_help=uninstrumented fun:argp_parse=uninstrumented fun:argp_state_help=uninstrumented fun:argp_usage=uninstrumented fun:argz_add=uninstrumented fun:argz_add_sep=uninstrumented fun:argz_append=uninstrumented fun:argz_count=uninstrumented fun:argz_create=uninstrumented fun:argz_create_sep=uninstrumented fun:argz_delete=uninstrumented fun:argz_extract=uninstrumented fun:argz_insert=uninstrumented fun:argz_next=uninstrumented fun:argz_replace=uninstrumented fun:argz_stringify=uninstrumented fun:asctime=uninstrumented fun:asctime_r=uninstrumented fun:asin=uninstrumented fun:asinf=uninstrumented fun:asinf128=uninstrumented fun:asinf32=uninstrumented fun:asinf32x=uninstrumented fun:asinf64=uninstrumented fun:asinf64x=uninstrumented fun:asinh=uninstrumented fun:asinhf=uninstrumented fun:asinhf128=uninstrumented fun:asinhf32=uninstrumented fun:asinhf32x=uninstrumented fun:asinhf64=uninstrumented fun:asinhf64x=uninstrumented fun:asinhl=uninstrumented fun:asinl=uninstrumented fun:asprintf=uninstrumented fun:at_quick_exit=uninstrumented fun:atan=uninstrumented fun:atan2=uninstrumented fun:atan2f=uninstrumented fun:atan2f128=uninstrumented fun:atan2f32=uninstrumented fun:atan2f32x=uninstrumented fun:atan2f64=uninstrumented fun:atan2f64x=uninstrumented fun:atan2l=uninstrumented fun:atanf=uninstrumented fun:atanf128=uninstrumented fun:atanf32=uninstrumented fun:atanf32x=uninstrumented fun:atanf64=uninstrumented fun:atanf64x=uninstrumented fun:atanh=uninstrumented fun:atanhf=uninstrumented fun:atanhf128=uninstrumented fun:atanhf32=uninstrumented fun:atanhf32x=uninstrumented fun:atanhf64=uninstrumented fun:atanhf64x=uninstrumented fun:atanhl=uninstrumented fun:atanl=uninstrumented fun:atexit=uninstrumented fun:atof=uninstrumented fun:atoi=uninstrumented fun:atol=uninstrumented fun:atoll=uninstrumented fun:authdes_create=uninstrumented fun:authdes_getucred=uninstrumented fun:authdes_pk_create=uninstrumented fun:authnone_create=uninstrumented fun:authunix_create=uninstrumented fun:authunix_create_default=uninstrumented fun:backtrace=uninstrumented fun:backtrace_symbols=uninstrumented fun:backtrace_symbols_fd=uninstrumented fun:basename=uninstrumented fun:bcmp=uninstrumented fun:bcopy=uninstrumented fun:bdflush=uninstrumented fun:bind=uninstrumented fun:bind_textdomain_codeset=uninstrumented fun:bindresvport=uninstrumented fun:bindtextdomain=uninstrumented fun:brk=uninstrumented fun:bsd_signal=uninstrumented fun:bsearch=uninstrumented fun:btowc=uninstrumented fun:bzero=uninstrumented fun:c16rtomb=uninstrumented fun:c32rtomb=uninstrumented fun:cabs=uninstrumented fun:cabsf=uninstrumented fun:cabsf128=uninstrumented fun:cabsf32=uninstrumented fun:cabsf32x=uninstrumented fun:cabsf64=uninstrumented fun:cabsf64x=uninstrumented fun:cabsl=uninstrumented fun:cacos=uninstrumented fun:cacosf=uninstrumented fun:cacosf128=uninstrumented fun:cacosf32=uninstrumented fun:cacosf32x=uninstrumented fun:cacosf64=uninstrumented fun:cacosf64x=uninstrumented fun:cacosh=uninstrumented fun:cacoshf=uninstrumented fun:cacoshf128=uninstrumented fun:cacoshf32=uninstrumented fun:cacoshf32x=uninstrumented fun:cacoshf64=uninstrumented fun:cacoshf64x=uninstrumented fun:cacoshl=uninstrumented fun:cacosl=uninstrumented fun:calloc=uninstrumented fun:callrpc=uninstrumented fun:canonicalize=uninstrumented fun:canonicalize_file_name=uninstrumented fun:canonicalizef=uninstrumented fun:canonicalizef128=uninstrumented fun:canonicalizef32=uninstrumented fun:canonicalizef32x=uninstrumented fun:canonicalizef64=uninstrumented fun:canonicalizef64x=uninstrumented fun:canonicalizel=uninstrumented fun:capget=uninstrumented fun:capset=uninstrumented fun:carg=uninstrumented fun:cargf=uninstrumented fun:cargf128=uninstrumented fun:cargf32=uninstrumented fun:cargf32x=uninstrumented fun:cargf64=uninstrumented fun:cargf64x=uninstrumented fun:cargl=uninstrumented fun:casin=uninstrumented fun:casinf=uninstrumented fun:casinf128=uninstrumented fun:casinf32=uninstrumented fun:casinf32x=uninstrumented fun:casinf64=uninstrumented fun:casinf64x=uninstrumented fun:casinh=uninstrumented fun:casinhf=uninstrumented fun:casinhf128=uninstrumented fun:casinhf32=uninstrumented fun:casinhf32x=uninstrumented fun:casinhf64=uninstrumented fun:casinhf64x=uninstrumented fun:casinhl=uninstrumented fun:casinl=uninstrumented fun:catan=uninstrumented fun:catanf=uninstrumented fun:catanf128=uninstrumented fun:catanf32=uninstrumented fun:catanf32x=uninstrumented fun:catanf64=uninstrumented fun:catanf64x=uninstrumented fun:catanh=uninstrumented fun:catanhf=uninstrumented fun:catanhf128=uninstrumented fun:catanhf32=uninstrumented fun:catanhf32x=uninstrumented fun:catanhf64=uninstrumented fun:catanhf64x=uninstrumented fun:catanhl=uninstrumented fun:catanl=uninstrumented fun:catclose=uninstrumented fun:catgets=uninstrumented fun:catopen=uninstrumented fun:cbc_crypt=uninstrumented fun:cbrt=uninstrumented fun:cbrtf=uninstrumented fun:cbrtf128=uninstrumented fun:cbrtf32=uninstrumented fun:cbrtf32x=uninstrumented fun:cbrtf64=uninstrumented fun:cbrtf64x=uninstrumented fun:cbrtl=uninstrumented fun:ccos=uninstrumented fun:ccosf=uninstrumented fun:ccosf128=uninstrumented fun:ccosf32=uninstrumented fun:ccosf32x=uninstrumented fun:ccosf64=uninstrumented fun:ccosf64x=uninstrumented fun:ccosh=uninstrumented fun:ccoshf=uninstrumented fun:ccoshf128=uninstrumented fun:ccoshf32=uninstrumented fun:ccoshf32x=uninstrumented fun:ccoshf64=uninstrumented fun:ccoshf64x=uninstrumented fun:ccoshl=uninstrumented fun:ccosl=uninstrumented fun:ceil=uninstrumented fun:ceilf=uninstrumented fun:ceilf128=uninstrumented fun:ceilf32=uninstrumented fun:ceilf32x=uninstrumented fun:ceilf64=uninstrumented fun:ceilf64x=uninstrumented fun:ceill=uninstrumented fun:cexp=uninstrumented fun:cexpf=uninstrumented fun:cexpf128=uninstrumented fun:cexpf32=uninstrumented fun:cexpf32x=uninstrumented fun:cexpf64=uninstrumented fun:cexpf64x=uninstrumented fun:cexpl=uninstrumented fun:cfgetispeed=uninstrumented fun:cfgetospeed=uninstrumented fun:cfmakeraw=uninstrumented fun:cfree=uninstrumented fun:cfsetispeed=uninstrumented fun:cfsetospeed=uninstrumented fun:cfsetspeed=uninstrumented fun:chdir=uninstrumented fun:chflags=uninstrumented fun:chmod=uninstrumented fun:chown=uninstrumented fun:chroot=uninstrumented fun:cimag=uninstrumented fun:cimagf=uninstrumented fun:cimagf128=uninstrumented fun:cimagf32=uninstrumented fun:cimagf32x=uninstrumented fun:cimagf64=uninstrumented fun:cimagf64x=uninstrumented fun:cimagl=uninstrumented fun:clearenv=uninstrumented fun:clearerr=uninstrumented fun:clearerr_unlocked=uninstrumented fun:clnt_broadcast=uninstrumented fun:clnt_create=uninstrumented fun:clnt_pcreateerror=uninstrumented fun:clnt_perrno=uninstrumented fun:clnt_perror=uninstrumented fun:clnt_spcreateerror=uninstrumented fun:clnt_sperrno=uninstrumented fun:clnt_sperror=uninstrumented fun:clntraw_create=uninstrumented fun:clnttcp_create=uninstrumented fun:clntudp_bufcreate=uninstrumented fun:clntudp_create=uninstrumented fun:clntunix_create=uninstrumented fun:clock=uninstrumented fun:clock_adjtime=uninstrumented fun:clock_getcpuclockid=uninstrumented fun:clock_getres=uninstrumented fun:clock_gettime=uninstrumented fun:clock_nanosleep=uninstrumented fun:clock_settime=uninstrumented fun:clog=uninstrumented fun:clog10=uninstrumented fun:clog10f=uninstrumented fun:clog10f128=uninstrumented fun:clog10f32=uninstrumented fun:clog10f32x=uninstrumented fun:clog10f64=uninstrumented fun:clog10f64x=uninstrumented fun:clog10l=uninstrumented fun:clogf=uninstrumented fun:clogf128=uninstrumented fun:clogf32=uninstrumented fun:clogf32x=uninstrumented fun:clogf64=uninstrumented fun:clogf64x=uninstrumented fun:clogl=uninstrumented fun:clone=uninstrumented fun:close=uninstrumented fun:closedir=uninstrumented fun:closelog=uninstrumented fun:confstr=uninstrumented fun:conj=uninstrumented fun:conjf=uninstrumented fun:conjf128=uninstrumented fun:conjf32=uninstrumented fun:conjf32x=uninstrumented fun:conjf64=uninstrumented fun:conjf64x=uninstrumented fun:conjl=uninstrumented fun:connect=uninstrumented fun:copy_file_range=uninstrumented fun:copysign=uninstrumented fun:copysignf=uninstrumented fun:copysignf128=uninstrumented fun:copysignf32=uninstrumented fun:copysignf32x=uninstrumented fun:copysignf64=uninstrumented fun:copysignf64x=uninstrumented fun:copysignl=uninstrumented fun:cos=uninstrumented fun:cosf=uninstrumented fun:cosf128=uninstrumented fun:cosf32=uninstrumented fun:cosf32x=uninstrumented fun:cosf64=uninstrumented fun:cosf64x=uninstrumented fun:cosh=uninstrumented fun:coshf=uninstrumented fun:coshf128=uninstrumented fun:coshf32=uninstrumented fun:coshf32x=uninstrumented fun:coshf64=uninstrumented fun:coshf64x=uninstrumented fun:coshl=uninstrumented fun:cosl=uninstrumented fun:cpow=uninstrumented fun:cpowf=uninstrumented fun:cpowf128=uninstrumented fun:cpowf32=uninstrumented fun:cpowf32x=uninstrumented fun:cpowf64=uninstrumented fun:cpowf64x=uninstrumented fun:cpowl=uninstrumented fun:cproj=uninstrumented fun:cprojf=uninstrumented fun:cprojf128=uninstrumented fun:cprojf32=uninstrumented fun:cprojf32x=uninstrumented fun:cprojf64=uninstrumented fun:cprojf64x=uninstrumented fun:cprojl=uninstrumented fun:creal=uninstrumented fun:crealf=uninstrumented fun:crealf128=uninstrumented fun:crealf32=uninstrumented fun:crealf32x=uninstrumented fun:crealf64=uninstrumented fun:crealf64x=uninstrumented fun:creall=uninstrumented fun:creat=uninstrumented fun:creat64=uninstrumented fun:create_module=uninstrumented fun:crypt=uninstrumented fun:crypt_r=uninstrumented fun:csin=uninstrumented fun:csinf=uninstrumented fun:csinf128=uninstrumented fun:csinf32=uninstrumented fun:csinf32x=uninstrumented fun:csinf64=uninstrumented fun:csinf64x=uninstrumented fun:csinh=uninstrumented fun:csinhf=uninstrumented fun:csinhf128=uninstrumented fun:csinhf32=uninstrumented fun:csinhf32x=uninstrumented fun:csinhf64=uninstrumented fun:csinhf64x=uninstrumented fun:csinhl=uninstrumented fun:csinl=uninstrumented fun:csqrt=uninstrumented fun:csqrtf=uninstrumented fun:csqrtf128=uninstrumented fun:csqrtf32=uninstrumented fun:csqrtf32x=uninstrumented fun:csqrtf64=uninstrumented fun:csqrtf64x=uninstrumented fun:csqrtl=uninstrumented fun:ctan=uninstrumented fun:ctanf=uninstrumented fun:ctanf128=uninstrumented fun:ctanf32=uninstrumented fun:ctanf32x=uninstrumented fun:ctanf64=uninstrumented fun:ctanf64x=uninstrumented fun:ctanh=uninstrumented fun:ctanhf=uninstrumented fun:ctanhf128=uninstrumented fun:ctanhf32=uninstrumented fun:ctanhf32x=uninstrumented fun:ctanhf64=uninstrumented fun:ctanhf64x=uninstrumented fun:ctanhl=uninstrumented fun:ctanl=uninstrumented fun:ctermid=uninstrumented fun:ctime=uninstrumented fun:ctime_r=uninstrumented fun:cuserid=uninstrumented fun:daemon=uninstrumented fun:dcgettext=uninstrumented fun:dcngettext=uninstrumented fun:delete_module=uninstrumented fun:des_setparity=uninstrumented fun:dgettext=uninstrumented fun:difftime=uninstrumented fun:dirfd=uninstrumented fun:dirname=uninstrumented fun:div=uninstrumented fun:dl_iterate_phdr=uninstrumented fun:dladdr=uninstrumented fun:dladdr1=uninstrumented fun:dlclose=uninstrumented fun:dlerror=uninstrumented fun:dlinfo=uninstrumented fun:dlmopen=uninstrumented fun:dlopen=uninstrumented fun:dlsym=uninstrumented fun:dlvsym=uninstrumented fun:dngettext=uninstrumented fun:dprintf=uninstrumented fun:drand48=uninstrumented fun:drand48_r=uninstrumented fun:drem=uninstrumented fun:dremf=uninstrumented fun:dreml=uninstrumented fun:dup=uninstrumented fun:dup2=uninstrumented fun:dup3=uninstrumented fun:duplocale=uninstrumented fun:dysize=uninstrumented fun:eaccess=uninstrumented fun:ecb_crypt=uninstrumented fun:ecvt=uninstrumented fun:ecvt_r=uninstrumented fun:encrypt=uninstrumented fun:encrypt_r=uninstrumented fun:endaliasent=uninstrumented fun:endfsent=uninstrumented fun:endgrent=uninstrumented fun:endhostent=uninstrumented fun:endmntent=uninstrumented fun:endnetent=uninstrumented fun:endnetgrent=uninstrumented fun:endprotoent=uninstrumented fun:endpwent=uninstrumented fun:endrpcent=uninstrumented fun:endservent=uninstrumented fun:endsgent=uninstrumented fun:endspent=uninstrumented fun:endttyent=uninstrumented fun:endusershell=uninstrumented fun:endutent=uninstrumented fun:endutxent=uninstrumented fun:envz_add=uninstrumented fun:envz_entry=uninstrumented fun:envz_get=uninstrumented fun:envz_merge=uninstrumented fun:envz_remove=uninstrumented fun:envz_strip=uninstrumented fun:epoll_create=uninstrumented fun:epoll_create1=uninstrumented fun:epoll_ctl=uninstrumented fun:epoll_pwait=uninstrumented fun:epoll_wait=uninstrumented fun:erand48=uninstrumented fun:erand48_r=uninstrumented fun:erf=uninstrumented fun:erfc=uninstrumented fun:erfcf=uninstrumented fun:erfcf128=uninstrumented fun:erfcf32=uninstrumented fun:erfcf32x=uninstrumented fun:erfcf64=uninstrumented fun:erfcf64x=uninstrumented fun:erfcl=uninstrumented fun:erff=uninstrumented fun:erff128=uninstrumented fun:erff32=uninstrumented fun:erff32x=uninstrumented fun:erff64=uninstrumented fun:erff64x=uninstrumented fun:erfl=uninstrumented fun:err=uninstrumented fun:error=uninstrumented fun:error_at_line=uninstrumented fun:errx=uninstrumented fun:ether_aton=uninstrumented fun:ether_aton_r=uninstrumented fun:ether_hostton=uninstrumented fun:ether_line=uninstrumented fun:ether_ntoa=uninstrumented fun:ether_ntoa_r=uninstrumented fun:ether_ntohost=uninstrumented fun:euidaccess=uninstrumented fun:eventfd=uninstrumented fun:eventfd_read=uninstrumented fun:eventfd_write=uninstrumented fun:execl=uninstrumented fun:execle=uninstrumented fun:execlp=uninstrumented fun:execv=uninstrumented fun:execve=uninstrumented fun:execvp=uninstrumented fun:execvpe=uninstrumented fun:exit=uninstrumented fun:exp=uninstrumented fun:exp10=uninstrumented fun:exp10f=uninstrumented fun:exp10f128=uninstrumented fun:exp10f32=uninstrumented fun:exp10f32x=uninstrumented fun:exp10f64=uninstrumented fun:exp10f64x=uninstrumented fun:exp10l=uninstrumented fun:exp2=uninstrumented fun:exp2f=uninstrumented fun:exp2f128=uninstrumented fun:exp2f32=uninstrumented fun:exp2f32x=uninstrumented fun:exp2f64=uninstrumented fun:exp2f64x=uninstrumented fun:exp2l=uninstrumented fun:expf=uninstrumented fun:expf128=uninstrumented fun:expf32=uninstrumented fun:expf32x=uninstrumented fun:expf64=uninstrumented fun:expf64x=uninstrumented fun:expl=uninstrumented fun:explicit_bzero=uninstrumented fun:expm1=uninstrumented fun:expm1f=uninstrumented fun:expm1f128=uninstrumented fun:expm1f32=uninstrumented fun:expm1f32x=uninstrumented fun:expm1f64=uninstrumented fun:expm1f64x=uninstrumented fun:expm1l=uninstrumented fun:fabs=uninstrumented fun:fabsf=uninstrumented fun:fabsf128=uninstrumented fun:fabsf32=uninstrumented fun:fabsf32x=uninstrumented fun:fabsf64=uninstrumented fun:fabsf64x=uninstrumented fun:fabsl=uninstrumented fun:faccessat=uninstrumented fun:fallocate=uninstrumented fun:fallocate64=uninstrumented fun:fanotify_init=uninstrumented fun:fanotify_mark=uninstrumented fun:fattach=uninstrumented fun:fchdir=uninstrumented fun:fchflags=uninstrumented fun:fchmod=uninstrumented fun:fchmodat=uninstrumented fun:fchown=uninstrumented fun:fchownat=uninstrumented fun:fclose=uninstrumented fun:fcloseall=uninstrumented fun:fcntl=uninstrumented fun:fcrypt=uninstrumented fun:fcvt=uninstrumented fun:fcvt_r=uninstrumented fun:fdatasync=uninstrumented fun:fdetach=uninstrumented fun:fdim=uninstrumented fun:fdimf=uninstrumented fun:fdimf128=uninstrumented fun:fdimf32=uninstrumented fun:fdimf32x=uninstrumented fun:fdimf64=uninstrumented fun:fdimf64x=uninstrumented fun:fdiml=uninstrumented fun:fdopen=uninstrumented fun:fdopendir=uninstrumented fun:feclearexcept=uninstrumented fun:fedisableexcept=uninstrumented fun:feenableexcept=uninstrumented fun:fegetenv=uninstrumented fun:fegetexcept=uninstrumented fun:fegetexceptflag=uninstrumented fun:fegetmode=uninstrumented fun:fegetround=uninstrumented fun:feholdexcept=uninstrumented fun:feof=uninstrumented fun:feof_unlocked=uninstrumented fun:feraiseexcept=uninstrumented fun:ferror=uninstrumented fun:ferror_unlocked=uninstrumented fun:fesetenv=uninstrumented fun:fesetexcept=uninstrumented fun:fesetexceptflag=uninstrumented fun:fesetmode=uninstrumented fun:fesetround=uninstrumented fun:fetestexcept=uninstrumented fun:fetestexceptflag=uninstrumented fun:feupdateenv=uninstrumented fun:fexecve=uninstrumented fun:fflush=uninstrumented fun:fflush_unlocked=uninstrumented fun:ffs=uninstrumented fun:ffsl=uninstrumented fun:ffsll=uninstrumented fun:fgetc=uninstrumented fun:fgetc_unlocked=uninstrumented fun:fgetgrent=uninstrumented fun:fgetgrent_r=uninstrumented fun:fgetpos=uninstrumented fun:fgetpos64=uninstrumented fun:fgetpwent=uninstrumented fun:fgetpwent_r=uninstrumented fun:fgets=uninstrumented fun:fgets_unlocked=uninstrumented fun:fgetsgent=uninstrumented fun:fgetsgent_r=uninstrumented fun:fgetspent=uninstrumented fun:fgetspent_r=uninstrumented fun:fgetwc=uninstrumented fun:fgetwc_unlocked=uninstrumented fun:fgetws=uninstrumented fun:fgetws_unlocked=uninstrumented fun:fgetxattr=uninstrumented fun:fileno=uninstrumented fun:fileno_unlocked=uninstrumented fun:finite=uninstrumented fun:finitef=uninstrumented fun:finitel=uninstrumented fun:flistxattr=uninstrumented fun:flock=uninstrumented fun:flockfile=uninstrumented fun:floor=uninstrumented fun:floorf=uninstrumented fun:floorf128=uninstrumented fun:floorf32=uninstrumented fun:floorf32x=uninstrumented fun:floorf64=uninstrumented fun:floorf64x=uninstrumented fun:floorl=uninstrumented fun:fma=uninstrumented fun:fmaf=uninstrumented fun:fmaf128=uninstrumented fun:fmaf32=uninstrumented fun:fmaf32x=uninstrumented fun:fmaf64=uninstrumented fun:fmaf64x=uninstrumented fun:fmal=uninstrumented fun:fmax=uninstrumented fun:fmaxf=uninstrumented fun:fmaxf128=uninstrumented fun:fmaxf32=uninstrumented fun:fmaxf32x=uninstrumented fun:fmaxf64=uninstrumented fun:fmaxf64x=uninstrumented fun:fmaxl=uninstrumented fun:fmaxmag=uninstrumented fun:fmaxmagf=uninstrumented fun:fmaxmagf128=uninstrumented fun:fmaxmagf32=uninstrumented fun:fmaxmagf32x=uninstrumented fun:fmaxmagf64=uninstrumented fun:fmaxmagf64x=uninstrumented fun:fmaxmagl=uninstrumented fun:fmemopen=uninstrumented fun:fmin=uninstrumented fun:fminf=uninstrumented fun:fminf128=uninstrumented fun:fminf32=uninstrumented fun:fminf32x=uninstrumented fun:fminf64=uninstrumented fun:fminf64x=uninstrumented fun:fminl=uninstrumented fun:fminmag=uninstrumented fun:fminmagf=uninstrumented fun:fminmagf128=uninstrumented fun:fminmagf32=uninstrumented fun:fminmagf32x=uninstrumented fun:fminmagf64=uninstrumented fun:fminmagf64x=uninstrumented fun:fminmagl=uninstrumented fun:fmod=uninstrumented fun:fmodf=uninstrumented fun:fmodf128=uninstrumented fun:fmodf32=uninstrumented fun:fmodf32x=uninstrumented fun:fmodf64=uninstrumented fun:fmodf64x=uninstrumented fun:fmodl=uninstrumented fun:fmtmsg=uninstrumented fun:fnmatch=uninstrumented fun:fopen=uninstrumented fun:fopen64=uninstrumented fun:fopencookie=uninstrumented fun:fork=uninstrumented fun:forkpty=uninstrumented fun:fpathconf=uninstrumented fun:fprintf=uninstrumented fun:fputc=uninstrumented fun:fputc_unlocked=uninstrumented fun:fputs=uninstrumented fun:fputs_unlocked=uninstrumented fun:fputwc=uninstrumented fun:fputwc_unlocked=uninstrumented fun:fputws=uninstrumented fun:fputws_unlocked=uninstrumented fun:fread=uninstrumented fun:fread_unlocked=uninstrumented fun:free=uninstrumented fun:freeaddrinfo=uninstrumented fun:freeifaddrs=uninstrumented fun:freelocale=uninstrumented fun:fremovexattr=uninstrumented fun:freopen=uninstrumented fun:freopen64=uninstrumented fun:frexp=uninstrumented fun:frexpf=uninstrumented fun:frexpf128=uninstrumented fun:frexpf32=uninstrumented fun:frexpf32x=uninstrumented fun:frexpf64=uninstrumented fun:frexpf64x=uninstrumented fun:frexpl=uninstrumented fun:fromfp=uninstrumented fun:fromfpf=uninstrumented fun:fromfpf128=uninstrumented fun:fromfpf32=uninstrumented fun:fromfpf32x=uninstrumented fun:fromfpf64=uninstrumented fun:fromfpf64x=uninstrumented fun:fromfpl=uninstrumented fun:fromfpx=uninstrumented fun:fromfpxf=uninstrumented fun:fromfpxf128=uninstrumented fun:fromfpxf32=uninstrumented fun:fromfpxf32x=uninstrumented fun:fromfpxf64=uninstrumented fun:fromfpxf64x=uninstrumented fun:fromfpxl=uninstrumented fun:fscanf=uninstrumented fun:fseek=uninstrumented fun:fseeko=uninstrumented fun:fseeko64=uninstrumented fun:fsetpos=uninstrumented fun:fsetpos64=uninstrumented fun:fsetxattr=uninstrumented fun:fstat=uninstrumented fun:fstat64=uninstrumented fun:fstatat=uninstrumented fun:fstatat64=uninstrumented fun:fstatfs=uninstrumented fun:fstatfs64=uninstrumented fun:fstatvfs=uninstrumented fun:fstatvfs64=uninstrumented fun:fsync=uninstrumented fun:ftell=uninstrumented fun:ftello=uninstrumented fun:ftello64=uninstrumented fun:ftime=uninstrumented fun:ftok=uninstrumented fun:ftruncate=uninstrumented fun:ftruncate64=uninstrumented fun:ftrylockfile=uninstrumented fun:fts64_children=uninstrumented fun:fts64_close=uninstrumented fun:fts64_open=uninstrumented fun:fts64_read=uninstrumented fun:fts64_set=uninstrumented fun:fts_children=uninstrumented fun:fts_close=uninstrumented fun:fts_open=uninstrumented fun:fts_read=uninstrumented fun:fts_set=uninstrumented fun:ftw=uninstrumented fun:ftw64=uninstrumented fun:funlockfile=uninstrumented fun:futimens=uninstrumented fun:futimes=uninstrumented fun:futimesat=uninstrumented fun:fwide=uninstrumented fun:fwprintf=uninstrumented fun:fwrite=uninstrumented fun:fwrite_unlocked=uninstrumented fun:fwscanf=uninstrumented fun:gai_cancel=uninstrumented fun:gai_error=uninstrumented fun:gai_strerror=uninstrumented fun:gai_suspend=uninstrumented fun:gamma=uninstrumented fun:gammaf=uninstrumented fun:gammal=uninstrumented fun:gcvt=uninstrumented fun:get_avphys_pages=uninstrumented fun:get_current_dir_name=uninstrumented fun:get_kernel_syms=uninstrumented fun:get_myaddress=uninstrumented fun:get_nprocs=uninstrumented fun:get_nprocs_conf=uninstrumented fun:get_phys_pages=uninstrumented fun:getaddrinfo=uninstrumented fun:getaddrinfo_a=uninstrumented fun:getaliasbyname=uninstrumented fun:getaliasbyname_r=uninstrumented fun:getaliasent=uninstrumented fun:getaliasent_r=uninstrumented fun:getauxval=uninstrumented fun:getc=uninstrumented fun:getc_unlocked=uninstrumented fun:getchar=uninstrumented fun:getchar_unlocked=uninstrumented fun:getcontext=uninstrumented fun:getcwd=uninstrumented fun:getdate=uninstrumented fun:getdate_r=uninstrumented fun:getdelim=uninstrumented fun:getdirentries=uninstrumented fun:getdirentries64=uninstrumented fun:getdomainname=uninstrumented fun:getdtablesize=uninstrumented fun:getegid=uninstrumented fun:getentropy=uninstrumented fun:getenv=uninstrumented fun:geteuid=uninstrumented fun:getfsent=uninstrumented fun:getfsfile=uninstrumented fun:getfsspec=uninstrumented fun:getgid=uninstrumented fun:getgrent=uninstrumented fun:getgrent_r=uninstrumented fun:getgrgid=uninstrumented fun:getgrgid_r=uninstrumented fun:getgrnam=uninstrumented fun:getgrnam_r=uninstrumented fun:getgrouplist=uninstrumented fun:getgroups=uninstrumented fun:gethostbyaddr=uninstrumented fun:gethostbyaddr_r=uninstrumented fun:gethostbyname=uninstrumented fun:gethostbyname2=uninstrumented fun:gethostbyname2_r=uninstrumented fun:gethostbyname_r=uninstrumented fun:gethostent=uninstrumented fun:gethostent_r=uninstrumented fun:gethostid=uninstrumented fun:gethostname=uninstrumented fun:getifaddrs=uninstrumented fun:getipv4sourcefilter=uninstrumented fun:getitimer=uninstrumented fun:getline=uninstrumented fun:getloadavg=uninstrumented fun:getlogin=uninstrumented fun:getlogin_r=uninstrumented fun:getmntent=uninstrumented fun:getmntent_r=uninstrumented fun:getmsg=uninstrumented fun:getnameinfo=uninstrumented fun:getnetbyaddr=uninstrumented fun:getnetbyaddr_r=uninstrumented fun:getnetbyname=uninstrumented fun:getnetbyname_r=uninstrumented fun:getnetent=uninstrumented fun:getnetent_r=uninstrumented fun:getnetgrent=uninstrumented fun:getnetgrent_r=uninstrumented fun:getnetname=uninstrumented fun:getopt=uninstrumented fun:getopt_long=uninstrumented fun:getopt_long_only=uninstrumented fun:getpagesize=uninstrumented fun:getpass=uninstrumented fun:getpayload=uninstrumented fun:getpayloadf=uninstrumented fun:getpayloadf128=uninstrumented fun:getpayloadf32=uninstrumented fun:getpayloadf32x=uninstrumented fun:getpayloadf64=uninstrumented fun:getpayloadf64x=uninstrumented fun:getpayloadl=uninstrumented fun:getpeername=uninstrumented fun:getpgid=uninstrumented fun:getpgrp=uninstrumented fun:getpid=uninstrumented fun:getpmsg=uninstrumented fun:getppid=uninstrumented fun:getpriority=uninstrumented fun:getprotobyname=uninstrumented fun:getprotobyname_r=uninstrumented fun:getprotobynumber=uninstrumented fun:getprotobynumber_r=uninstrumented fun:getprotoent=uninstrumented fun:getprotoent_r=uninstrumented fun:getpt=uninstrumented fun:getpublickey=uninstrumented fun:getpw=uninstrumented fun:getpwent=uninstrumented fun:getpwent_r=uninstrumented fun:getpwnam=uninstrumented fun:getpwnam_r=uninstrumented fun:getpwuid=uninstrumented fun:getpwuid_r=uninstrumented fun:getrandom=uninstrumented fun:getresgid=uninstrumented fun:getresuid=uninstrumented fun:getrlimit=uninstrumented fun:getrlimit64=uninstrumented fun:getrpcbyname=uninstrumented fun:getrpcbyname_r=uninstrumented fun:getrpcbynumber=uninstrumented fun:getrpcbynumber_r=uninstrumented fun:getrpcent=uninstrumented fun:getrpcent_r=uninstrumented fun:getrpcport=uninstrumented fun:getrusage=uninstrumented fun:gets=uninstrumented fun:getsecretkey=uninstrumented fun:getservbyname=uninstrumented fun:getservbyname_r=uninstrumented fun:getservbyport=uninstrumented fun:getservbyport_r=uninstrumented fun:getservent=uninstrumented fun:getservent_r=uninstrumented fun:getsgent=uninstrumented fun:getsgent_r=uninstrumented fun:getsgnam=uninstrumented fun:getsgnam_r=uninstrumented fun:getsid=uninstrumented fun:getsockname=uninstrumented fun:getsockopt=uninstrumented fun:getsourcefilter=uninstrumented fun:getspent=uninstrumented fun:getspent_r=uninstrumented fun:getspnam=uninstrumented fun:getspnam_r=uninstrumented fun:getsubopt=uninstrumented fun:gettext=uninstrumented fun:gettimeofday=uninstrumented fun:getttyent=uninstrumented fun:getttynam=uninstrumented fun:getuid=uninstrumented fun:getusershell=uninstrumented fun:getutent=uninstrumented fun:getutent_r=uninstrumented fun:getutid=uninstrumented fun:getutid_r=uninstrumented fun:getutline=uninstrumented fun:getutline_r=uninstrumented fun:getutmp=uninstrumented fun:getutmpx=uninstrumented fun:getutxent=uninstrumented fun:getutxid=uninstrumented fun:getutxline=uninstrumented fun:getw=uninstrumented fun:getwc=uninstrumented fun:getwc_unlocked=uninstrumented fun:getwchar=uninstrumented fun:getwchar_unlocked=uninstrumented fun:getwd=uninstrumented fun:getxattr=uninstrumented fun:glob=uninstrumented fun:glob64=uninstrumented fun:glob_pattern_p=uninstrumented fun:globfree=uninstrumented fun:globfree64=uninstrumented fun:gmtime=uninstrumented fun:gmtime_r=uninstrumented fun:gnu_dev_major=uninstrumented fun:gnu_dev_makedev=uninstrumented fun:gnu_dev_minor=uninstrumented fun:gnu_get_libc_release=uninstrumented fun:gnu_get_libc_version=uninstrumented fun:grantpt=uninstrumented fun:group_member=uninstrumented fun:gsignal=uninstrumented fun:gtty=uninstrumented fun:hasmntopt=uninstrumented fun:hcreate=uninstrumented fun:hcreate_r=uninstrumented fun:hdestroy=uninstrumented fun:hdestroy_r=uninstrumented fun:herror=uninstrumented fun:host2netname=uninstrumented fun:hsearch=uninstrumented fun:hsearch_r=uninstrumented fun:hstrerror=uninstrumented fun:htonl=uninstrumented fun:htons=uninstrumented fun:hypot=uninstrumented fun:hypotf=uninstrumented fun:hypotf128=uninstrumented fun:hypotf32=uninstrumented fun:hypotf32x=uninstrumented fun:hypotf64=uninstrumented fun:hypotf64x=uninstrumented fun:hypotl=uninstrumented fun:iconv=uninstrumented fun:iconv_close=uninstrumented fun:iconv_open=uninstrumented fun:idna_to_ascii_lz=uninstrumented fun:idna_to_unicode_lzlz=uninstrumented fun:if_freenameindex=uninstrumented fun:if_indextoname=uninstrumented fun:if_nameindex=uninstrumented fun:if_nametoindex=uninstrumented fun:ilogb=uninstrumented fun:ilogbf=uninstrumented fun:ilogbf128=uninstrumented fun:ilogbf32=uninstrumented fun:ilogbf32x=uninstrumented fun:ilogbf64=uninstrumented fun:ilogbf64x=uninstrumented fun:ilogbl=uninstrumented fun:imaxabs=uninstrumented fun:imaxdiv=uninstrumented fun:index=uninstrumented fun:inet6_opt_append=uninstrumented fun:inet6_opt_find=uninstrumented fun:inet6_opt_finish=uninstrumented fun:inet6_opt_get_val=uninstrumented fun:inet6_opt_init=uninstrumented fun:inet6_opt_next=uninstrumented fun:inet6_opt_set_val=uninstrumented fun:inet6_option_alloc=uninstrumented fun:inet6_option_append=uninstrumented fun:inet6_option_find=uninstrumented fun:inet6_option_init=uninstrumented fun:inet6_option_next=uninstrumented fun:inet6_option_space=uninstrumented fun:inet6_rth_add=uninstrumented fun:inet6_rth_getaddr=uninstrumented fun:inet6_rth_init=uninstrumented fun:inet6_rth_reverse=uninstrumented fun:inet6_rth_segments=uninstrumented fun:inet6_rth_space=uninstrumented fun:inet_addr=uninstrumented fun:inet_aton=uninstrumented fun:inet_lnaof=uninstrumented fun:inet_makeaddr=uninstrumented fun:inet_net_ntop=uninstrumented fun:inet_net_pton=uninstrumented fun:inet_neta=uninstrumented fun:inet_netof=uninstrumented fun:inet_network=uninstrumented fun:inet_nsap_addr=uninstrumented fun:inet_nsap_ntoa=uninstrumented fun:inet_ntoa=uninstrumented fun:inet_ntop=uninstrumented fun:inet_pton=uninstrumented fun:init_module=uninstrumented fun:initgroups=uninstrumented fun:initstate=uninstrumented fun:initstate_r=uninstrumented fun:innetgr=uninstrumented fun:inotify_add_watch=uninstrumented fun:inotify_init=uninstrumented fun:inotify_init1=uninstrumented fun:inotify_rm_watch=uninstrumented fun:insque=uninstrumented fun:ioctl=uninstrumented fun:ioperm=uninstrumented fun:iopl=uninstrumented fun:iruserok=uninstrumented fun:iruserok_af=uninstrumented fun:isalnum=uninstrumented fun:isalnum_l=uninstrumented fun:isalpha=uninstrumented fun:isalpha_l=uninstrumented fun:isascii=uninstrumented fun:isastream=uninstrumented fun:isatty=uninstrumented fun:isblank=uninstrumented fun:isblank_l=uninstrumented fun:iscntrl=uninstrumented fun:iscntrl_l=uninstrumented fun:isctype=uninstrumented fun:isdigit=uninstrumented fun:isdigit_l=uninstrumented fun:isfdtype=uninstrumented fun:isgraph=uninstrumented fun:isgraph_l=uninstrumented fun:isinf=uninstrumented fun:isinfd128=uninstrumented fun:isinfd32=uninstrumented fun:isinfd64=uninstrumented fun:isinff=uninstrumented fun:isinfl=uninstrumented fun:islower=uninstrumented fun:islower_l=uninstrumented fun:isnan=uninstrumented fun:isnanf=uninstrumented fun:isnanl=uninstrumented fun:isprint=uninstrumented fun:isprint_l=uninstrumented fun:ispunct=uninstrumented fun:ispunct_l=uninstrumented fun:isspace=uninstrumented fun:isspace_l=uninstrumented fun:isupper=uninstrumented fun:isupper_l=uninstrumented fun:iswalnum=uninstrumented fun:iswalnum_l=uninstrumented fun:iswalpha=uninstrumented fun:iswalpha_l=uninstrumented fun:iswblank=uninstrumented fun:iswblank_l=uninstrumented fun:iswcntrl=uninstrumented fun:iswcntrl_l=uninstrumented fun:iswctype=uninstrumented fun:iswctype_l=uninstrumented fun:iswdigit=uninstrumented fun:iswdigit_l=uninstrumented fun:iswgraph=uninstrumented fun:iswgraph_l=uninstrumented fun:iswlower=uninstrumented fun:iswlower_l=uninstrumented fun:iswprint=uninstrumented fun:iswprint_l=uninstrumented fun:iswpunct=uninstrumented fun:iswpunct_l=uninstrumented fun:iswspace=uninstrumented fun:iswspace_l=uninstrumented fun:iswupper=uninstrumented fun:iswupper_l=uninstrumented fun:iswxdigit=uninstrumented fun:iswxdigit_l=uninstrumented fun:isxdigit=uninstrumented fun:isxdigit_l=uninstrumented fun:j0=uninstrumented fun:j0f=uninstrumented fun:j0f128=uninstrumented fun:j0f32=uninstrumented fun:j0f32x=uninstrumented fun:j0f64=uninstrumented fun:j0f64x=uninstrumented fun:j0l=uninstrumented fun:j1=uninstrumented fun:j1f=uninstrumented fun:j1f128=uninstrumented fun:j1f32=uninstrumented fun:j1f32x=uninstrumented fun:j1f64=uninstrumented fun:j1f64x=uninstrumented fun:j1l=uninstrumented fun:jn=uninstrumented fun:jnf=uninstrumented fun:jnf128=uninstrumented fun:jnf32=uninstrumented fun:jnf32x=uninstrumented fun:jnf64=uninstrumented fun:jnf64x=uninstrumented fun:jnl=uninstrumented fun:jrand48=uninstrumented fun:jrand48_r=uninstrumented fun:key_decryptsession=uninstrumented fun:key_decryptsession_pk=uninstrumented fun:key_encryptsession=uninstrumented fun:key_encryptsession_pk=uninstrumented fun:key_gendes=uninstrumented fun:key_get_conv=uninstrumented fun:key_secretkey_is_set=uninstrumented fun:key_setnet=uninstrumented fun:key_setsecret=uninstrumented fun:kill=uninstrumented fun:killpg=uninstrumented fun:klogctl=uninstrumented fun:l64a=uninstrumented fun:labs=uninstrumented fun:lchmod=uninstrumented fun:lchown=uninstrumented fun:lckpwdf=uninstrumented fun:lcong48=uninstrumented fun:lcong48_r=uninstrumented fun:ldexp=uninstrumented fun:ldexpf=uninstrumented fun:ldexpf128=uninstrumented fun:ldexpf32=uninstrumented fun:ldexpf32x=uninstrumented fun:ldexpf64=uninstrumented fun:ldexpf64x=uninstrumented fun:ldexpl=uninstrumented fun:ldiv=uninstrumented fun:lfind=uninstrumented fun:lgamma=uninstrumented fun:lgamma_r=uninstrumented fun:lgammaf=uninstrumented fun:lgammaf128=uninstrumented fun:lgammaf128_r=uninstrumented fun:lgammaf32=uninstrumented fun:lgammaf32_r=uninstrumented fun:lgammaf32x=uninstrumented fun:lgammaf32x_r=uninstrumented fun:lgammaf64=uninstrumented fun:lgammaf64_r=uninstrumented fun:lgammaf64x=uninstrumented fun:lgammaf64x_r=uninstrumented fun:lgammaf_r=uninstrumented fun:lgammal=uninstrumented fun:lgammal_r=uninstrumented fun:lgetxattr=uninstrumented fun:link=uninstrumented fun:linkat=uninstrumented fun:lio_listio=uninstrumented fun:lio_listio64=uninstrumented fun:listen=uninstrumented fun:listxattr=uninstrumented fun:llabs=uninstrumented fun:lldiv=uninstrumented fun:llistxattr=uninstrumented fun:llogb=uninstrumented fun:llogbf=uninstrumented fun:llogbf128=uninstrumented fun:llogbf32=uninstrumented fun:llogbf32x=uninstrumented fun:llogbf64=uninstrumented fun:llogbf64x=uninstrumented fun:llogbl=uninstrumented fun:llrint=uninstrumented fun:llrintf=uninstrumented fun:llrintf128=uninstrumented fun:llrintf32=uninstrumented fun:llrintf32x=uninstrumented fun:llrintf64=uninstrumented fun:llrintf64x=uninstrumented fun:llrintl=uninstrumented fun:llround=uninstrumented fun:llroundf=uninstrumented fun:llroundf128=uninstrumented fun:llroundf32=uninstrumented fun:llroundf32x=uninstrumented fun:llroundf64=uninstrumented fun:llroundf64x=uninstrumented fun:llroundl=uninstrumented fun:llseek=uninstrumented fun:localeconv=uninstrumented fun:localtime=uninstrumented fun:localtime_r=uninstrumented fun:lockf=uninstrumented fun:lockf64=uninstrumented fun:log=uninstrumented fun:log10=uninstrumented fun:log10f=uninstrumented fun:log10f128=uninstrumented fun:log10f32=uninstrumented fun:log10f32x=uninstrumented fun:log10f64=uninstrumented fun:log10f64x=uninstrumented fun:log10l=uninstrumented fun:log1p=uninstrumented fun:log1pf=uninstrumented fun:log1pf128=uninstrumented fun:log1pf32=uninstrumented fun:log1pf32x=uninstrumented fun:log1pf64=uninstrumented fun:log1pf64x=uninstrumented fun:log1pl=uninstrumented fun:log2=uninstrumented fun:log2f=uninstrumented fun:log2f128=uninstrumented fun:log2f32=uninstrumented fun:log2f32x=uninstrumented fun:log2f64=uninstrumented fun:log2f64x=uninstrumented fun:log2l=uninstrumented fun:logb=uninstrumented fun:logbf=uninstrumented fun:logbf128=uninstrumented fun:logbf32=uninstrumented fun:logbf32x=uninstrumented fun:logbf64=uninstrumented fun:logbf64x=uninstrumented fun:logbl=uninstrumented fun:logf=uninstrumented fun:logf128=uninstrumented fun:logf32=uninstrumented fun:logf32x=uninstrumented fun:logf64=uninstrumented fun:logf64x=uninstrumented fun:login=uninstrumented fun:login_tty=uninstrumented fun:logl=uninstrumented fun:logout=uninstrumented fun:logwtmp=uninstrumented fun:longjmp=uninstrumented fun:lrand48=uninstrumented fun:lrand48_r=uninstrumented fun:lremovexattr=uninstrumented fun:lrint=uninstrumented fun:lrintf=uninstrumented fun:lrintf128=uninstrumented fun:lrintf32=uninstrumented fun:lrintf32x=uninstrumented fun:lrintf64=uninstrumented fun:lrintf64x=uninstrumented fun:lrintl=uninstrumented fun:lround=uninstrumented fun:lroundf=uninstrumented fun:lroundf128=uninstrumented fun:lroundf32=uninstrumented fun:lroundf32x=uninstrumented fun:lroundf64=uninstrumented fun:lroundf64x=uninstrumented fun:lroundl=uninstrumented fun:lsearch=uninstrumented fun:lseek=uninstrumented fun:lseek64=uninstrumented fun:lsetxattr=uninstrumented fun:lstat=uninstrumented fun:lstat64=uninstrumented fun:lutimes=uninstrumented fun:madvise=uninstrumented fun:makecontext=uninstrumented fun:mallinfo=uninstrumented fun:malloc=uninstrumented fun:malloc_get_state=uninstrumented fun:malloc_info=uninstrumented fun:malloc_set_state=uninstrumented fun:malloc_stats=uninstrumented fun:malloc_trim=uninstrumented fun:malloc_usable_size=uninstrumented fun:mallopt=uninstrumented fun:matherr=uninstrumented fun:mblen=uninstrumented fun:mbrlen=uninstrumented fun:mbrtoc16=uninstrumented fun:mbrtoc32=uninstrumented fun:mbrtowc=uninstrumented fun:mbsinit=uninstrumented fun:mbsnrtowcs=uninstrumented fun:mbsrtowcs=uninstrumented fun:mbstowcs=uninstrumented fun:mbtowc=uninstrumented fun:mcheck=uninstrumented fun:mcheck_check_all=uninstrumented fun:mcheck_pedantic=uninstrumented fun:mcount=uninstrumented fun:memalign=uninstrumented fun:memccpy=uninstrumented fun:memchr=uninstrumented fun:memcmp=uninstrumented fun:memcpy=uninstrumented fun:memfd_create=uninstrumented fun:memfrob=uninstrumented fun:memmem=uninstrumented fun:memmove=uninstrumented fun:mempcpy=uninstrumented fun:memrchr=uninstrumented fun:memset=uninstrumented fun:mincore=uninstrumented fun:mkdir=uninstrumented fun:mkdirat=uninstrumented fun:mkdtemp=uninstrumented fun:mkfifo=uninstrumented fun:mkfifoat=uninstrumented fun:mknod=uninstrumented fun:mknodat=uninstrumented fun:mkostemp=uninstrumented fun:mkostemp64=uninstrumented fun:mkostemps=uninstrumented fun:mkostemps64=uninstrumented fun:mkstemp=uninstrumented fun:mkstemp64=uninstrumented fun:mkstemps=uninstrumented fun:mkstemps64=uninstrumented fun:mktemp=uninstrumented fun:mktime=uninstrumented fun:mlock=uninstrumented fun:mlock2=uninstrumented fun:mlockall=uninstrumented fun:mmap=uninstrumented fun:mmap64=uninstrumented fun:modf=uninstrumented fun:modff=uninstrumented fun:modff128=uninstrumented fun:modff32=uninstrumented fun:modff32x=uninstrumented fun:modff64=uninstrumented fun:modff64x=uninstrumented fun:modfl=uninstrumented fun:modify_ldt=uninstrumented fun:moncontrol=uninstrumented fun:monstartup=uninstrumented fun:mount=uninstrumented fun:mprobe=uninstrumented fun:mprotect=uninstrumented fun:mq_close=uninstrumented fun:mq_getattr=uninstrumented fun:mq_notify=uninstrumented fun:mq_open=uninstrumented fun:mq_receive=uninstrumented fun:mq_send=uninstrumented fun:mq_setattr=uninstrumented fun:mq_timedreceive=uninstrumented fun:mq_timedsend=uninstrumented fun:mq_unlink=uninstrumented fun:mrand48=uninstrumented fun:mrand48_r=uninstrumented fun:mremap=uninstrumented fun:msgctl=uninstrumented fun:msgget=uninstrumented fun:msgrcv=uninstrumented fun:msgsnd=uninstrumented fun:msync=uninstrumented fun:mtrace=uninstrumented fun:munlock=uninstrumented fun:munlockall=uninstrumented fun:munmap=uninstrumented fun:muntrace=uninstrumented fun:name_to_handle_at=uninstrumented fun:nan=uninstrumented fun:nanf=uninstrumented fun:nanf128=uninstrumented fun:nanf32=uninstrumented fun:nanf32x=uninstrumented fun:nanf64=uninstrumented fun:nanf64x=uninstrumented fun:nanl=uninstrumented fun:nanosleep=uninstrumented fun:nearbyint=uninstrumented fun:nearbyintf=uninstrumented fun:nearbyintf128=uninstrumented fun:nearbyintf32=uninstrumented fun:nearbyintf32x=uninstrumented fun:nearbyintf64=uninstrumented fun:nearbyintf64x=uninstrumented fun:nearbyintl=uninstrumented fun:netname2host=uninstrumented fun:netname2user=uninstrumented fun:newlocale=uninstrumented fun:nextafter=uninstrumented fun:nextafterf=uninstrumented fun:nextafterf128=uninstrumented fun:nextafterf32=uninstrumented fun:nextafterf32x=uninstrumented fun:nextafterf64=uninstrumented fun:nextafterf64x=uninstrumented fun:nextafterl=uninstrumented fun:nextdown=uninstrumented fun:nextdownf=uninstrumented fun:nextdownf128=uninstrumented fun:nextdownf32=uninstrumented fun:nextdownf32x=uninstrumented fun:nextdownf64=uninstrumented fun:nextdownf64x=uninstrumented fun:nextdownl=uninstrumented fun:nexttoward=uninstrumented fun:nexttowardf=uninstrumented fun:nexttowardl=uninstrumented fun:nextup=uninstrumented fun:nextupf=uninstrumented fun:nextupf128=uninstrumented fun:nextupf32=uninstrumented fun:nextupf32x=uninstrumented fun:nextupf64=uninstrumented fun:nextupf64x=uninstrumented fun:nextupl=uninstrumented fun:nfsservctl=uninstrumented fun:nftw=uninstrumented fun:nftw64=uninstrumented fun:ngettext=uninstrumented fun:nice=uninstrumented fun:nis_add=uninstrumented fun:nis_add_entry=uninstrumented fun:nis_addmember=uninstrumented fun:nis_checkpoint=uninstrumented fun:nis_clone_directory=uninstrumented fun:nis_clone_object=uninstrumented fun:nis_clone_result=uninstrumented fun:nis_creategroup=uninstrumented fun:nis_destroy_object=uninstrumented fun:nis_destroygroup=uninstrumented fun:nis_dir_cmp=uninstrumented fun:nis_domain_of=uninstrumented fun:nis_domain_of_r=uninstrumented fun:nis_first_entry=uninstrumented fun:nis_free_directory=uninstrumented fun:nis_free_object=uninstrumented fun:nis_free_request=uninstrumented fun:nis_freenames=uninstrumented fun:nis_freeresult=uninstrumented fun:nis_freeservlist=uninstrumented fun:nis_freetags=uninstrumented fun:nis_getnames=uninstrumented fun:nis_getservlist=uninstrumented fun:nis_ismember=uninstrumented fun:nis_leaf_of=uninstrumented fun:nis_leaf_of_r=uninstrumented fun:nis_lerror=uninstrumented fun:nis_list=uninstrumented fun:nis_local_directory=uninstrumented fun:nis_local_group=uninstrumented fun:nis_local_host=uninstrumented fun:nis_local_principal=uninstrumented fun:nis_lookup=uninstrumented fun:nis_mkdir=uninstrumented fun:nis_modify=uninstrumented fun:nis_modify_entry=uninstrumented fun:nis_name_of=uninstrumented fun:nis_name_of_r=uninstrumented fun:nis_next_entry=uninstrumented fun:nis_perror=uninstrumented fun:nis_ping=uninstrumented fun:nis_print_directory=uninstrumented fun:nis_print_entry=uninstrumented fun:nis_print_group=uninstrumented fun:nis_print_group_entry=uninstrumented fun:nis_print_link=uninstrumented fun:nis_print_object=uninstrumented fun:nis_print_result=uninstrumented fun:nis_print_rights=uninstrumented fun:nis_print_table=uninstrumented fun:nis_read_obj=uninstrumented fun:nis_remove=uninstrumented fun:nis_remove_entry=uninstrumented fun:nis_removemember=uninstrumented fun:nis_rmdir=uninstrumented fun:nis_servstate=uninstrumented fun:nis_sperrno=uninstrumented fun:nis_sperror=uninstrumented fun:nis_sperror_r=uninstrumented fun:nis_stats=uninstrumented fun:nis_verifygroup=uninstrumented fun:nis_write_obj=uninstrumented fun:nl_langinfo=uninstrumented fun:nl_langinfo_l=uninstrumented fun:nrand48=uninstrumented fun:nrand48_r=uninstrumented fun:ns_datetosecs=uninstrumented fun:ns_format_ttl=uninstrumented fun:ns_get16=uninstrumented fun:ns_get32=uninstrumented fun:ns_initparse=uninstrumented fun:ns_makecanon=uninstrumented fun:ns_msg_getflag=uninstrumented fun:ns_name_compress=uninstrumented fun:ns_name_ntol=uninstrumented fun:ns_name_ntop=uninstrumented fun:ns_name_pack=uninstrumented fun:ns_name_pton=uninstrumented fun:ns_name_rollback=uninstrumented fun:ns_name_skip=uninstrumented fun:ns_name_uncompress=uninstrumented fun:ns_name_unpack=uninstrumented fun:ns_parse_ttl=uninstrumented fun:ns_parserr=uninstrumented fun:ns_put16=uninstrumented fun:ns_put32=uninstrumented fun:ns_samedomain=uninstrumented fun:ns_samename=uninstrumented fun:ns_skiprr=uninstrumented fun:ns_sprintrr=uninstrumented fun:ns_sprintrrf=uninstrumented fun:ns_subdomain=uninstrumented fun:ntohl=uninstrumented fun:ntohs=uninstrumented fun:ntp_adjtime=uninstrumented fun:ntp_gettime=uninstrumented fun:ntp_gettimex=uninstrumented fun:obstack_free=uninstrumented fun:obstack_printf=uninstrumented fun:obstack_vprintf=uninstrumented fun:on_exit=uninstrumented fun:open=uninstrumented fun:open64=uninstrumented fun:open_by_handle_at=uninstrumented fun:open_memstream=uninstrumented fun:open_wmemstream=uninstrumented fun:openat=uninstrumented fun:openat64=uninstrumented fun:opendir=uninstrumented fun:openlog=uninstrumented fun:openpty=uninstrumented fun:parse_printf_format=uninstrumented fun:passwd2des=uninstrumented fun:pathconf=uninstrumented fun:pause=uninstrumented fun:pclose=uninstrumented fun:perror=uninstrumented fun:personality=uninstrumented fun:pipe=uninstrumented fun:pipe2=uninstrumented fun:pivot_root=uninstrumented fun:pkey_alloc=uninstrumented fun:pkey_free=uninstrumented fun:pkey_get=uninstrumented fun:pkey_mprotect=uninstrumented fun:pkey_set=uninstrumented fun:pmap_getmaps=uninstrumented fun:pmap_getport=uninstrumented fun:pmap_rmtcall=uninstrumented fun:pmap_set=uninstrumented fun:pmap_unset=uninstrumented fun:poll=uninstrumented fun:popen=uninstrumented fun:posix_fadvise=uninstrumented fun:posix_fadvise64=uninstrumented fun:posix_fallocate=uninstrumented fun:posix_fallocate64=uninstrumented fun:posix_madvise=uninstrumented fun:posix_memalign=uninstrumented fun:posix_openpt=uninstrumented fun:posix_spawn=uninstrumented fun:posix_spawn_file_actions_addclose=uninstrumented fun:posix_spawn_file_actions_adddup2=uninstrumented fun:posix_spawn_file_actions_addopen=uninstrumented fun:posix_spawn_file_actions_destroy=uninstrumented fun:posix_spawn_file_actions_init=uninstrumented fun:posix_spawnattr_destroy=uninstrumented fun:posix_spawnattr_getflags=uninstrumented fun:posix_spawnattr_getpgroup=uninstrumented fun:posix_spawnattr_getschedparam=uninstrumented fun:posix_spawnattr_getschedpolicy=uninstrumented fun:posix_spawnattr_getsigdefault=uninstrumented fun:posix_spawnattr_getsigmask=uninstrumented fun:posix_spawnattr_init=uninstrumented fun:posix_spawnattr_setflags=uninstrumented fun:posix_spawnattr_setpgroup=uninstrumented fun:posix_spawnattr_setschedparam=uninstrumented fun:posix_spawnattr_setschedpolicy=uninstrumented fun:posix_spawnattr_setsigdefault=uninstrumented fun:posix_spawnattr_setsigmask=uninstrumented fun:posix_spawnp=uninstrumented fun:pow=uninstrumented fun:pow10=uninstrumented fun:pow10f=uninstrumented fun:pow10l=uninstrumented fun:powf=uninstrumented fun:powf128=uninstrumented fun:powf32=uninstrumented fun:powf32x=uninstrumented fun:powf64=uninstrumented fun:powf64x=uninstrumented fun:powl=uninstrumented fun:ppoll=uninstrumented fun:prctl=uninstrumented fun:pread=uninstrumented fun:pread64=uninstrumented fun:preadv=uninstrumented fun:preadv2=uninstrumented fun:preadv64=uninstrumented fun:preadv64v2=uninstrumented fun:printf=uninstrumented fun:printf_size=uninstrumented fun:printf_size_info=uninstrumented fun:prlimit=uninstrumented fun:prlimit64=uninstrumented fun:process_vm_readv=uninstrumented fun:process_vm_writev=uninstrumented fun:profil=uninstrumented fun:pselect=uninstrumented fun:psiginfo=uninstrumented fun:psignal=uninstrumented fun:pthread_atfork=uninstrumented fun:pthread_attr_destroy=uninstrumented fun:pthread_attr_getaffinity_np=uninstrumented fun:pthread_attr_getdetachstate=uninstrumented fun:pthread_attr_getguardsize=uninstrumented fun:pthread_attr_getinheritsched=uninstrumented fun:pthread_attr_getschedparam=uninstrumented fun:pthread_attr_getschedpolicy=uninstrumented fun:pthread_attr_getscope=uninstrumented fun:pthread_attr_getstack=uninstrumented fun:pthread_attr_getstackaddr=uninstrumented fun:pthread_attr_getstacksize=uninstrumented fun:pthread_attr_init=uninstrumented fun:pthread_attr_setaffinity_np=uninstrumented fun:pthread_attr_setdetachstate=uninstrumented fun:pthread_attr_setguardsize=uninstrumented fun:pthread_attr_setinheritsched=uninstrumented fun:pthread_attr_setschedparam=uninstrumented fun:pthread_attr_setschedpolicy=uninstrumented fun:pthread_attr_setscope=uninstrumented fun:pthread_attr_setstack=uninstrumented fun:pthread_attr_setstackaddr=uninstrumented fun:pthread_attr_setstacksize=uninstrumented fun:pthread_barrier_destroy=uninstrumented fun:pthread_barrier_init=uninstrumented fun:pthread_barrier_wait=uninstrumented fun:pthread_barrierattr_destroy=uninstrumented fun:pthread_barrierattr_getpshared=uninstrumented fun:pthread_barrierattr_init=uninstrumented fun:pthread_barrierattr_setpshared=uninstrumented fun:pthread_cancel=uninstrumented fun:pthread_cond_broadcast=uninstrumented fun:pthread_cond_destroy=uninstrumented fun:pthread_cond_init=uninstrumented fun:pthread_cond_signal=uninstrumented fun:pthread_cond_timedwait=uninstrumented fun:pthread_cond_wait=uninstrumented fun:pthread_condattr_destroy=uninstrumented fun:pthread_condattr_getclock=uninstrumented fun:pthread_condattr_getpshared=uninstrumented fun:pthread_condattr_init=uninstrumented fun:pthread_condattr_setclock=uninstrumented fun:pthread_condattr_setpshared=uninstrumented fun:pthread_create=uninstrumented fun:pthread_detach=uninstrumented fun:pthread_equal=uninstrumented fun:pthread_exit=uninstrumented fun:pthread_getaffinity_np=uninstrumented fun:pthread_getattr_default_np=uninstrumented fun:pthread_getattr_np=uninstrumented fun:pthread_getconcurrency=uninstrumented fun:pthread_getcpuclockid=uninstrumented fun:pthread_getname_np=uninstrumented fun:pthread_getschedparam=uninstrumented fun:pthread_getspecific=uninstrumented fun:pthread_join=uninstrumented fun:pthread_key_create=uninstrumented fun:pthread_key_delete=uninstrumented fun:pthread_kill=uninstrumented fun:pthread_kill_other_threads_np=uninstrumented fun:pthread_mutex_consistent=uninstrumented fun:pthread_mutex_consistent_np=uninstrumented fun:pthread_mutex_destroy=uninstrumented fun:pthread_mutex_getprioceiling=uninstrumented fun:pthread_mutex_init=uninstrumented fun:pthread_mutex_lock=uninstrumented fun:pthread_mutex_setprioceiling=uninstrumented fun:pthread_mutex_timedlock=uninstrumented fun:pthread_mutex_trylock=uninstrumented fun:pthread_mutex_unlock=uninstrumented fun:pthread_mutexattr_destroy=uninstrumented fun:pthread_mutexattr_getkind_np=uninstrumented fun:pthread_mutexattr_getprioceiling=uninstrumented fun:pthread_mutexattr_getprotocol=uninstrumented fun:pthread_mutexattr_getpshared=uninstrumented fun:pthread_mutexattr_getrobust=uninstrumented fun:pthread_mutexattr_getrobust_np=uninstrumented fun:pthread_mutexattr_gettype=uninstrumented fun:pthread_mutexattr_init=uninstrumented fun:pthread_mutexattr_setkind_np=uninstrumented fun:pthread_mutexattr_setprioceiling=uninstrumented fun:pthread_mutexattr_setprotocol=uninstrumented fun:pthread_mutexattr_setpshared=uninstrumented fun:pthread_mutexattr_setrobust=uninstrumented fun:pthread_mutexattr_setrobust_np=uninstrumented fun:pthread_mutexattr_settype=uninstrumented fun:pthread_once=uninstrumented fun:pthread_rwlock_destroy=uninstrumented fun:pthread_rwlock_init=uninstrumented fun:pthread_rwlock_rdlock=uninstrumented fun:pthread_rwlock_timedrdlock=uninstrumented fun:pthread_rwlock_timedwrlock=uninstrumented fun:pthread_rwlock_tryrdlock=uninstrumented fun:pthread_rwlock_trywrlock=uninstrumented fun:pthread_rwlock_unlock=uninstrumented fun:pthread_rwlock_wrlock=uninstrumented fun:pthread_rwlockattr_destroy=uninstrumented fun:pthread_rwlockattr_getkind_np=uninstrumented fun:pthread_rwlockattr_getpshared=uninstrumented fun:pthread_rwlockattr_init=uninstrumented fun:pthread_rwlockattr_setkind_np=uninstrumented fun:pthread_rwlockattr_setpshared=uninstrumented fun:pthread_self=uninstrumented fun:pthread_setaffinity_np=uninstrumented fun:pthread_setattr_default_np=uninstrumented fun:pthread_setcancelstate=uninstrumented fun:pthread_setcanceltype=uninstrumented fun:pthread_setconcurrency=uninstrumented fun:pthread_setname_np=uninstrumented fun:pthread_setschedparam=uninstrumented fun:pthread_setschedprio=uninstrumented fun:pthread_setspecific=uninstrumented fun:pthread_sigmask=uninstrumented fun:pthread_sigqueue=uninstrumented fun:pthread_spin_destroy=uninstrumented fun:pthread_spin_init=uninstrumented fun:pthread_spin_lock=uninstrumented fun:pthread_spin_trylock=uninstrumented fun:pthread_spin_unlock=uninstrumented fun:pthread_testcancel=uninstrumented fun:pthread_timedjoin_np=uninstrumented fun:pthread_tryjoin_np=uninstrumented fun:pthread_yield=uninstrumented fun:ptrace=uninstrumented fun:ptsname=uninstrumented fun:ptsname_r=uninstrumented fun:putc=uninstrumented fun:putc_unlocked=uninstrumented fun:putchar=uninstrumented fun:putchar_unlocked=uninstrumented fun:putenv=uninstrumented fun:putgrent=uninstrumented fun:putmsg=uninstrumented fun:putpmsg=uninstrumented fun:putpwent=uninstrumented fun:puts=uninstrumented fun:putsgent=uninstrumented fun:putspent=uninstrumented fun:pututline=uninstrumented fun:pututxline=uninstrumented fun:putw=uninstrumented fun:putwc=uninstrumented fun:putwc_unlocked=uninstrumented fun:putwchar=uninstrumented fun:putwchar_unlocked=uninstrumented fun:pvalloc=uninstrumented fun:pwrite=uninstrumented fun:pwrite64=uninstrumented fun:pwritev=uninstrumented fun:pwritev2=uninstrumented fun:pwritev64=uninstrumented fun:pwritev64v2=uninstrumented fun:qecvt=uninstrumented fun:qecvt_r=uninstrumented fun:qfcvt=uninstrumented fun:qfcvt_r=uninstrumented fun:qgcvt=uninstrumented fun:qsort=uninstrumented fun:qsort_r=uninstrumented fun:query_module=uninstrumented fun:quick_exit=uninstrumented fun:quotactl=uninstrumented fun:raise=uninstrumented fun:rand=uninstrumented fun:rand_r=uninstrumented fun:random=uninstrumented fun:random_r=uninstrumented fun:rawmemchr=uninstrumented fun:rcmd=uninstrumented fun:rcmd_af=uninstrumented fun:re_comp=uninstrumented fun:re_compile_fastmap=uninstrumented fun:re_compile_pattern=uninstrumented fun:re_exec=uninstrumented fun:re_match=uninstrumented fun:re_match_2=uninstrumented fun:re_search=uninstrumented fun:re_search_2=uninstrumented fun:re_set_registers=uninstrumented fun:re_set_syntax=uninstrumented fun:read=uninstrumented fun:readColdStartFile=uninstrumented fun:readahead=uninstrumented fun:readdir=uninstrumented fun:readdir64=uninstrumented fun:readdir64_r=uninstrumented fun:readdir_r=uninstrumented fun:readlink=uninstrumented fun:readlinkat=uninstrumented fun:readv=uninstrumented fun:realloc=uninstrumented fun:reallocarray=uninstrumented fun:realpath=uninstrumented fun:reboot=uninstrumented fun:recv=uninstrumented fun:recvfrom=uninstrumented fun:recvmmsg=uninstrumented fun:recvmsg=uninstrumented fun:regcomp=uninstrumented fun:regerror=uninstrumented fun:regexec=uninstrumented fun:regfree=uninstrumented fun:register_printf_function=uninstrumented fun:register_printf_modifier=uninstrumented fun:register_printf_specifier=uninstrumented fun:register_printf_type=uninstrumented fun:registerrpc=uninstrumented fun:remainder=uninstrumented fun:remainderf=uninstrumented fun:remainderf128=uninstrumented fun:remainderf32=uninstrumented fun:remainderf32x=uninstrumented fun:remainderf64=uninstrumented fun:remainderf64x=uninstrumented fun:remainderl=uninstrumented fun:remap_file_pages=uninstrumented fun:remove=uninstrumented fun:removexattr=uninstrumented fun:remque=uninstrumented fun:remquo=uninstrumented fun:remquof=uninstrumented fun:remquof128=uninstrumented fun:remquof32=uninstrumented fun:remquof32x=uninstrumented fun:remquof64=uninstrumented fun:remquof64x=uninstrumented fun:remquol=uninstrumented fun:rename=uninstrumented fun:renameat=uninstrumented fun:res_gethostbyaddr=uninstrumented fun:res_gethostbyname=uninstrumented fun:res_gethostbyname2=uninstrumented fun:res_send_setqhook=uninstrumented fun:res_send_setrhook=uninstrumented fun:revoke=uninstrumented fun:rewind=uninstrumented fun:rewinddir=uninstrumented fun:rexec=uninstrumented fun:rexec_af=uninstrumented fun:rindex=uninstrumented fun:rint=uninstrumented fun:rintf=uninstrumented fun:rintf128=uninstrumented fun:rintf32=uninstrumented fun:rintf32x=uninstrumented fun:rintf64=uninstrumented fun:rintf64x=uninstrumented fun:rintl=uninstrumented fun:rmdir=uninstrumented fun:round=uninstrumented fun:roundeven=uninstrumented fun:roundevenf=uninstrumented fun:roundevenf128=uninstrumented fun:roundevenf32=uninstrumented fun:roundevenf32x=uninstrumented fun:roundevenf64=uninstrumented fun:roundevenf64x=uninstrumented fun:roundevenl=uninstrumented fun:roundf=uninstrumented fun:roundf128=uninstrumented fun:roundf32=uninstrumented fun:roundf32x=uninstrumented fun:roundf64=uninstrumented fun:roundf64x=uninstrumented fun:roundl=uninstrumented fun:rpmatch=uninstrumented fun:rresvport=uninstrumented fun:rresvport_af=uninstrumented fun:rtime=uninstrumented fun:ruserok=uninstrumented fun:ruserok_af=uninstrumented fun:ruserpass=uninstrumented fun:sbrk=uninstrumented fun:scalb=uninstrumented fun:scalbf=uninstrumented fun:scalbl=uninstrumented fun:scalbln=uninstrumented fun:scalblnf=uninstrumented fun:scalblnf128=uninstrumented fun:scalblnf32=uninstrumented fun:scalblnf32x=uninstrumented fun:scalblnf64=uninstrumented fun:scalblnf64x=uninstrumented fun:scalblnl=uninstrumented fun:scalbn=uninstrumented fun:scalbnf=uninstrumented fun:scalbnf128=uninstrumented fun:scalbnf32=uninstrumented fun:scalbnf32x=uninstrumented fun:scalbnf64=uninstrumented fun:scalbnf64x=uninstrumented fun:scalbnl=uninstrumented fun:scandir=uninstrumented fun:scandir64=uninstrumented fun:scandirat=uninstrumented fun:scandirat64=uninstrumented fun:scanf=uninstrumented fun:sched_get_priority_max=uninstrumented fun:sched_get_priority_min=uninstrumented fun:sched_getaffinity=uninstrumented fun:sched_getcpu=uninstrumented fun:sched_getparam=uninstrumented fun:sched_getscheduler=uninstrumented fun:sched_rr_get_interval=uninstrumented fun:sched_setaffinity=uninstrumented fun:sched_setparam=uninstrumented fun:sched_setscheduler=uninstrumented fun:sched_yield=uninstrumented fun:secure_getenv=uninstrumented fun:seed48=uninstrumented fun:seed48_r=uninstrumented fun:seekdir=uninstrumented fun:select=uninstrumented fun:sem_close=uninstrumented fun:sem_destroy=uninstrumented fun:sem_getvalue=uninstrumented fun:sem_init=uninstrumented fun:sem_open=uninstrumented fun:sem_post=uninstrumented fun:sem_timedwait=uninstrumented fun:sem_trywait=uninstrumented fun:sem_unlink=uninstrumented fun:sem_wait=uninstrumented fun:semctl=uninstrumented fun:semget=uninstrumented fun:semop=uninstrumented fun:semtimedop=uninstrumented fun:send=uninstrumented fun:sendfile=uninstrumented fun:sendfile64=uninstrumented fun:sendmmsg=uninstrumented fun:sendmsg=uninstrumented fun:sendto=uninstrumented fun:setaliasent=uninstrumented fun:setbuf=uninstrumented fun:setbuffer=uninstrumented fun:setcontext=uninstrumented fun:setdomainname=uninstrumented fun:setegid=uninstrumented fun:setenv=uninstrumented fun:seteuid=uninstrumented fun:setfsent=uninstrumented fun:setfsgid=uninstrumented fun:setfsuid=uninstrumented fun:setgid=uninstrumented fun:setgrent=uninstrumented fun:setgroups=uninstrumented fun:sethostent=uninstrumented fun:sethostid=uninstrumented fun:sethostname=uninstrumented fun:setipv4sourcefilter=uninstrumented fun:setitimer=uninstrumented fun:setjmp=uninstrumented fun:setkey=uninstrumented fun:setkey_r=uninstrumented fun:setlinebuf=uninstrumented fun:setlocale=uninstrumented fun:setlogin=uninstrumented fun:setlogmask=uninstrumented fun:setmntent=uninstrumented fun:setnetent=uninstrumented fun:setnetgrent=uninstrumented fun:setns=uninstrumented fun:setpayload=uninstrumented fun:setpayloadf=uninstrumented fun:setpayloadf128=uninstrumented fun:setpayloadf32=uninstrumented fun:setpayloadf32x=uninstrumented fun:setpayloadf64=uninstrumented fun:setpayloadf64x=uninstrumented fun:setpayloadl=uninstrumented fun:setpayloadsig=uninstrumented fun:setpayloadsigf=uninstrumented fun:setpayloadsigf128=uninstrumented fun:setpayloadsigf32=uninstrumented fun:setpayloadsigf32x=uninstrumented fun:setpayloadsigf64=uninstrumented fun:setpayloadsigf64x=uninstrumented fun:setpayloadsigl=uninstrumented fun:setpgid=uninstrumented fun:setpgrp=uninstrumented fun:setpriority=uninstrumented fun:setprotoent=uninstrumented fun:setpwent=uninstrumented fun:setregid=uninstrumented fun:setresgid=uninstrumented fun:setresuid=uninstrumented fun:setreuid=uninstrumented fun:setrlimit=uninstrumented fun:setrlimit64=uninstrumented fun:setrpcent=uninstrumented fun:setservent=uninstrumented fun:setsgent=uninstrumented fun:setsid=uninstrumented fun:setsockopt=uninstrumented fun:setsourcefilter=uninstrumented fun:setspent=uninstrumented fun:setstate=uninstrumented fun:setstate_r=uninstrumented fun:settimeofday=uninstrumented fun:setttyent=uninstrumented fun:setuid=uninstrumented fun:setusershell=uninstrumented fun:setutent=uninstrumented fun:setutxent=uninstrumented fun:setvbuf=uninstrumented fun:setxattr=uninstrumented fun:sgetsgent=uninstrumented fun:sgetsgent_r=uninstrumented fun:sgetspent=uninstrumented fun:sgetspent_r=uninstrumented fun:shm_open=uninstrumented fun:shm_unlink=uninstrumented fun:shmat=uninstrumented fun:shmctl=uninstrumented fun:shmdt=uninstrumented fun:shmget=uninstrumented fun:shutdown=uninstrumented fun:sigaction=uninstrumented fun:sigaddset=uninstrumented fun:sigaltstack=uninstrumented fun:sigandset=uninstrumented fun:sigblock=uninstrumented fun:sigdelset=uninstrumented fun:sigemptyset=uninstrumented fun:sigfillset=uninstrumented fun:siggetmask=uninstrumented fun:sighold=uninstrumented fun:sigignore=uninstrumented fun:siginterrupt=uninstrumented fun:sigisemptyset=uninstrumented fun:sigismember=uninstrumented fun:siglongjmp=uninstrumented fun:signal=uninstrumented fun:signalfd=uninstrumented fun:significand=uninstrumented fun:significandf=uninstrumented fun:significandl=uninstrumented fun:sigorset=uninstrumented fun:sigpause=uninstrumented fun:sigpending=uninstrumented fun:sigprocmask=uninstrumented fun:sigqueue=uninstrumented fun:sigrelse=uninstrumented fun:sigreturn=uninstrumented fun:sigset=uninstrumented fun:sigsetmask=uninstrumented fun:sigstack=uninstrumented fun:sigsuspend=uninstrumented fun:sigtimedwait=uninstrumented fun:sigvec=uninstrumented fun:sigwait=uninstrumented fun:sigwaitinfo=uninstrumented fun:sin=uninstrumented fun:sincos=uninstrumented fun:sincosf=uninstrumented fun:sincosf128=uninstrumented fun:sincosf32=uninstrumented fun:sincosf32x=uninstrumented fun:sincosf64=uninstrumented fun:sincosf64x=uninstrumented fun:sincosl=uninstrumented fun:sinf=uninstrumented fun:sinf128=uninstrumented fun:sinf32=uninstrumented fun:sinf32x=uninstrumented fun:sinf64=uninstrumented fun:sinf64x=uninstrumented fun:sinh=uninstrumented fun:sinhf=uninstrumented fun:sinhf128=uninstrumented fun:sinhf32=uninstrumented fun:sinhf32x=uninstrumented fun:sinhf64=uninstrumented fun:sinhf64x=uninstrumented fun:sinhl=uninstrumented fun:sinl=uninstrumented fun:sleep=uninstrumented fun:snprintf=uninstrumented fun:sockatmark=uninstrumented fun:socket=uninstrumented fun:socketpair=uninstrumented fun:splice=uninstrumented fun:sprintf=uninstrumented fun:sprofil=uninstrumented fun:sqrt=uninstrumented fun:sqrtf=uninstrumented fun:sqrtf128=uninstrumented fun:sqrtf32=uninstrumented fun:sqrtf32x=uninstrumented fun:sqrtf64=uninstrumented fun:sqrtf64x=uninstrumented fun:sqrtl=uninstrumented fun:srand=uninstrumented fun:srand48=uninstrumented fun:srand48_r=uninstrumented fun:srandom=uninstrumented fun:srandom_r=uninstrumented fun:sscanf=uninstrumented fun:ssignal=uninstrumented fun:sstk=uninstrumented fun:stat=uninstrumented fun:stat64=uninstrumented fun:statfs=uninstrumented fun:statfs64=uninstrumented fun:statvfs=uninstrumented fun:statvfs64=uninstrumented fun:step=uninstrumented fun:stime=uninstrumented fun:stpcpy=uninstrumented fun:stpncpy=uninstrumented fun:strcasecmp=uninstrumented fun:strcasecmp_l=uninstrumented fun:strcasestr=uninstrumented fun:strcat=uninstrumented fun:strchr=uninstrumented fun:strchrnul=uninstrumented fun:strcmp=uninstrumented fun:strcoll=uninstrumented fun:strcoll_l=uninstrumented fun:strcpy=uninstrumented fun:strcspn=uninstrumented fun:strdup=uninstrumented fun:strerror=uninstrumented fun:strerror_l=uninstrumented fun:strerror_r=uninstrumented fun:strfmon=uninstrumented fun:strfmon_l=uninstrumented fun:strfromd=uninstrumented fun:strfromf=uninstrumented fun:strfromf128=uninstrumented fun:strfromf32=uninstrumented fun:strfromf32x=uninstrumented fun:strfromf64=uninstrumented fun:strfromf64x=uninstrumented fun:strfroml=uninstrumented fun:strfry=uninstrumented fun:strftime=uninstrumented fun:strftime_l=uninstrumented fun:strlen=uninstrumented fun:strncasecmp=uninstrumented fun:strncasecmp_l=uninstrumented fun:strncat=uninstrumented fun:strncmp=uninstrumented fun:strncpy=uninstrumented fun:strndup=uninstrumented fun:strnlen=uninstrumented fun:strpbrk=uninstrumented fun:strptime=uninstrumented fun:strptime_l=uninstrumented fun:strrchr=uninstrumented fun:strsep=uninstrumented fun:strsignal=uninstrumented fun:strspn=uninstrumented fun:strstr=uninstrumented fun:strtod=uninstrumented fun:strtod_l=uninstrumented fun:strtof=uninstrumented fun:strtof128=uninstrumented fun:strtof128_l=uninstrumented fun:strtof32=uninstrumented fun:strtof32_l=uninstrumented fun:strtof32x=uninstrumented fun:strtof32x_l=uninstrumented fun:strtof64=uninstrumented fun:strtof64_l=uninstrumented fun:strtof64x=uninstrumented fun:strtof64x_l=uninstrumented fun:strtof_l=uninstrumented fun:strtoimax=uninstrumented fun:strtok=uninstrumented fun:strtok_r=uninstrumented fun:strtol=uninstrumented fun:strtol_l=uninstrumented fun:strtold=uninstrumented fun:strtold_l=uninstrumented fun:strtoll=uninstrumented fun:strtoll_l=uninstrumented fun:strtoq=uninstrumented fun:strtoul=uninstrumented fun:strtoul_l=uninstrumented fun:strtoull=uninstrumented fun:strtoull_l=uninstrumented fun:strtoumax=uninstrumented fun:strtouq=uninstrumented fun:strverscmp=uninstrumented fun:strxfrm=uninstrumented fun:strxfrm_l=uninstrumented fun:stty=uninstrumented fun:svc_exit=uninstrumented fun:svc_getreq=uninstrumented fun:svc_getreq_common=uninstrumented fun:svc_getreq_poll=uninstrumented fun:svc_getreqset=uninstrumented fun:svc_register=uninstrumented fun:svc_run=uninstrumented fun:svc_sendreply=uninstrumented fun:svc_unregister=uninstrumented fun:svcerr_auth=uninstrumented fun:svcerr_decode=uninstrumented fun:svcerr_noproc=uninstrumented fun:svcerr_noprog=uninstrumented fun:svcerr_progvers=uninstrumented fun:svcerr_systemerr=uninstrumented fun:svcerr_weakauth=uninstrumented fun:svcfd_create=uninstrumented fun:svcraw_create=uninstrumented fun:svctcp_create=uninstrumented fun:svcudp_bufcreate=uninstrumented fun:svcudp_create=uninstrumented fun:svcudp_enablecache=uninstrumented fun:svcunix_create=uninstrumented fun:svcunixfd_create=uninstrumented fun:swab=uninstrumented fun:swapcontext=uninstrumented fun:swapoff=uninstrumented fun:swapon=uninstrumented fun:swprintf=uninstrumented fun:swscanf=uninstrumented fun:symlink=uninstrumented fun:symlinkat=uninstrumented fun:sync=uninstrumented fun:sync_file_range=uninstrumented fun:syncfs=uninstrumented fun:syscall=uninstrumented fun:sysconf=uninstrumented fun:sysctl=uninstrumented fun:sysinfo=uninstrumented fun:syslog=uninstrumented fun:system=uninstrumented fun:sysv_signal=uninstrumented fun:tan=uninstrumented fun:tanf=uninstrumented fun:tanf128=uninstrumented fun:tanf32=uninstrumented fun:tanf32x=uninstrumented fun:tanf64=uninstrumented fun:tanf64x=uninstrumented fun:tanh=uninstrumented fun:tanhf=uninstrumented fun:tanhf128=uninstrumented fun:tanhf32=uninstrumented fun:tanhf32x=uninstrumented fun:tanhf64=uninstrumented fun:tanhf64x=uninstrumented fun:tanhl=uninstrumented fun:tanl=uninstrumented fun:tcdrain=uninstrumented fun:tcflow=uninstrumented fun:tcflush=uninstrumented fun:tcgetattr=uninstrumented fun:tcgetpgrp=uninstrumented fun:tcgetsid=uninstrumented fun:tcsendbreak=uninstrumented fun:tcsetattr=uninstrumented fun:tcsetpgrp=uninstrumented fun:td_init=uninstrumented fun:td_log=uninstrumented fun:td_symbol_list=uninstrumented fun:td_ta_clear_event=uninstrumented fun:td_ta_delete=uninstrumented fun:td_ta_enable_stats=uninstrumented fun:td_ta_event_addr=uninstrumented fun:td_ta_event_getmsg=uninstrumented fun:td_ta_get_nthreads=uninstrumented fun:td_ta_get_ph=uninstrumented fun:td_ta_get_stats=uninstrumented fun:td_ta_map_id2thr=uninstrumented fun:td_ta_map_lwp2thr=uninstrumented fun:td_ta_new=uninstrumented fun:td_ta_reset_stats=uninstrumented fun:td_ta_set_event=uninstrumented fun:td_ta_setconcurrency=uninstrumented fun:td_ta_thr_iter=uninstrumented fun:td_ta_tsd_iter=uninstrumented fun:td_thr_clear_event=uninstrumented fun:td_thr_dbresume=uninstrumented fun:td_thr_dbsuspend=uninstrumented fun:td_thr_event_enable=uninstrumented fun:td_thr_event_getmsg=uninstrumented fun:td_thr_get_info=uninstrumented fun:td_thr_getfpregs=uninstrumented fun:td_thr_getgregs=uninstrumented fun:td_thr_getxregs=uninstrumented fun:td_thr_getxregsize=uninstrumented fun:td_thr_set_event=uninstrumented fun:td_thr_setfpregs=uninstrumented fun:td_thr_setgregs=uninstrumented fun:td_thr_setprio=uninstrumented fun:td_thr_setsigpending=uninstrumented fun:td_thr_setxregs=uninstrumented fun:td_thr_sigsetmask=uninstrumented fun:td_thr_tls_get_addr=uninstrumented fun:td_thr_tlsbase=uninstrumented fun:td_thr_tsd=uninstrumented fun:td_thr_validate=uninstrumented fun:tdelete=uninstrumented fun:tdestroy=uninstrumented fun:tee=uninstrumented fun:telldir=uninstrumented fun:tempnam=uninstrumented fun:textdomain=uninstrumented fun:tfind=uninstrumented fun:tgamma=uninstrumented fun:tgammaf=uninstrumented fun:tgammaf128=uninstrumented fun:tgammaf32=uninstrumented fun:tgammaf32x=uninstrumented fun:tgammaf64=uninstrumented fun:tgammaf64x=uninstrumented fun:tgammal=uninstrumented fun:time=uninstrumented fun:timegm=uninstrumented fun:timelocal=uninstrumented fun:timer_create=uninstrumented fun:timer_delete=uninstrumented fun:timer_getoverrun=uninstrumented fun:timer_gettime=uninstrumented fun:timer_settime=uninstrumented fun:timerfd_create=uninstrumented fun:timerfd_gettime=uninstrumented fun:timerfd_settime=uninstrumented fun:times=uninstrumented fun:timespec_get=uninstrumented fun:tmpfile=uninstrumented fun:tmpfile64=uninstrumented fun:tmpnam=uninstrumented fun:tmpnam_r=uninstrumented fun:toascii=uninstrumented fun:tolower=uninstrumented fun:tolower_l=uninstrumented fun:totalorder=uninstrumented fun:totalorderf=uninstrumented fun:totalorderf128=uninstrumented fun:totalorderf32=uninstrumented fun:totalorderf32x=uninstrumented fun:totalorderf64=uninstrumented fun:totalorderf64x=uninstrumented fun:totalorderl=uninstrumented fun:totalordermag=uninstrumented fun:totalordermagf=uninstrumented fun:totalordermagf128=uninstrumented fun:totalordermagf32=uninstrumented fun:totalordermagf32x=uninstrumented fun:totalordermagf64=uninstrumented fun:totalordermagf64x=uninstrumented fun:totalordermagl=uninstrumented fun:toupper=uninstrumented fun:toupper_l=uninstrumented fun:towctrans=uninstrumented fun:towctrans_l=uninstrumented fun:towlower=uninstrumented fun:towlower_l=uninstrumented fun:towupper=uninstrumented fun:towupper_l=uninstrumented fun:tr_break=uninstrumented fun:trunc=uninstrumented fun:truncate=uninstrumented fun:truncate64=uninstrumented fun:truncf=uninstrumented fun:truncf128=uninstrumented fun:truncf32=uninstrumented fun:truncf32x=uninstrumented fun:truncf64=uninstrumented fun:truncf64x=uninstrumented fun:truncl=uninstrumented fun:tsearch=uninstrumented fun:ttyname=uninstrumented fun:ttyname_r=uninstrumented fun:ttyslot=uninstrumented fun:twalk=uninstrumented fun:tzset=uninstrumented fun:ualarm=uninstrumented fun:ufromfp=uninstrumented fun:ufromfpf=uninstrumented fun:ufromfpf128=uninstrumented fun:ufromfpf32=uninstrumented fun:ufromfpf32x=uninstrumented fun:ufromfpf64=uninstrumented fun:ufromfpf64x=uninstrumented fun:ufromfpl=uninstrumented fun:ufromfpx=uninstrumented fun:ufromfpxf=uninstrumented fun:ufromfpxf128=uninstrumented fun:ufromfpxf32=uninstrumented fun:ufromfpxf32x=uninstrumented fun:ufromfpxf64=uninstrumented fun:ufromfpxf64x=uninstrumented fun:ufromfpxl=uninstrumented fun:ulckpwdf=uninstrumented fun:ulimit=uninstrumented fun:umask=uninstrumented fun:umount=uninstrumented fun:umount2=uninstrumented fun:uname=uninstrumented fun:ungetc=uninstrumented fun:ungetwc=uninstrumented fun:unlink=uninstrumented fun:unlinkat=uninstrumented fun:unlockpt=uninstrumented fun:unsetenv=uninstrumented fun:unshare=uninstrumented fun:updwtmp=uninstrumented fun:updwtmpx=uninstrumented fun:uselib=uninstrumented fun:uselocale=uninstrumented fun:user2netname=uninstrumented fun:usleep=uninstrumented fun:ustat=uninstrumented fun:utime=uninstrumented fun:utimensat=uninstrumented fun:utimes=uninstrumented fun:utmpname=uninstrumented fun:utmpxname=uninstrumented fun:valloc=uninstrumented fun:vasprintf=uninstrumented fun:vdprintf=uninstrumented fun:verr=uninstrumented fun:verrx=uninstrumented fun:versionsort=uninstrumented fun:versionsort64=uninstrumented fun:vfork=uninstrumented fun:vfprintf=uninstrumented fun:vfscanf=uninstrumented fun:vfwprintf=uninstrumented fun:vfwscanf=uninstrumented fun:vhangup=uninstrumented fun:vlimit=uninstrumented fun:vmsplice=uninstrumented fun:vprintf=uninstrumented fun:vscanf=uninstrumented fun:vsnprintf=uninstrumented fun:vsprintf=uninstrumented fun:vsscanf=uninstrumented fun:vswprintf=uninstrumented fun:vswscanf=uninstrumented fun:vsyslog=uninstrumented fun:vtimes=uninstrumented fun:vwarn=uninstrumented fun:vwarnx=uninstrumented fun:vwprintf=uninstrumented fun:vwscanf=uninstrumented fun:wait=uninstrumented fun:wait3=uninstrumented fun:wait4=uninstrumented fun:waitid=uninstrumented fun:waitpid=uninstrumented fun:warn=uninstrumented fun:warnx=uninstrumented fun:wcpcpy=uninstrumented fun:wcpncpy=uninstrumented fun:wcrtomb=uninstrumented fun:wcscasecmp=uninstrumented fun:wcscasecmp_l=uninstrumented fun:wcscat=uninstrumented fun:wcschr=uninstrumented fun:wcschrnul=uninstrumented fun:wcscmp=uninstrumented fun:wcscoll=uninstrumented fun:wcscoll_l=uninstrumented fun:wcscpy=uninstrumented fun:wcscspn=uninstrumented fun:wcsdup=uninstrumented fun:wcsftime=uninstrumented fun:wcsftime_l=uninstrumented fun:wcslen=uninstrumented fun:wcsncasecmp=uninstrumented fun:wcsncasecmp_l=uninstrumented fun:wcsncat=uninstrumented fun:wcsncmp=uninstrumented fun:wcsncpy=uninstrumented fun:wcsnlen=uninstrumented fun:wcsnrtombs=uninstrumented fun:wcspbrk=uninstrumented fun:wcsrchr=uninstrumented fun:wcsrtombs=uninstrumented fun:wcsspn=uninstrumented fun:wcsstr=uninstrumented fun:wcstod=uninstrumented fun:wcstod_l=uninstrumented fun:wcstof=uninstrumented fun:wcstof128=uninstrumented fun:wcstof128_l=uninstrumented fun:wcstof32=uninstrumented fun:wcstof32_l=uninstrumented fun:wcstof32x=uninstrumented fun:wcstof32x_l=uninstrumented fun:wcstof64=uninstrumented fun:wcstof64_l=uninstrumented fun:wcstof64x=uninstrumented fun:wcstof64x_l=uninstrumented fun:wcstof_l=uninstrumented fun:wcstoimax=uninstrumented fun:wcstok=uninstrumented fun:wcstol=uninstrumented fun:wcstol_l=uninstrumented fun:wcstold=uninstrumented fun:wcstold_l=uninstrumented fun:wcstoll=uninstrumented fun:wcstoll_l=uninstrumented fun:wcstombs=uninstrumented fun:wcstoq=uninstrumented fun:wcstoul=uninstrumented fun:wcstoul_l=uninstrumented fun:wcstoull=uninstrumented fun:wcstoull_l=uninstrumented fun:wcstoumax=uninstrumented fun:wcstouq=uninstrumented fun:wcswcs=uninstrumented fun:wcswidth=uninstrumented fun:wcsxfrm=uninstrumented fun:wcsxfrm_l=uninstrumented fun:wctob=uninstrumented fun:wctomb=uninstrumented fun:wctrans=uninstrumented fun:wctrans_l=uninstrumented fun:wctype=uninstrumented fun:wctype_l=uninstrumented fun:wcwidth=uninstrumented fun:wmemchr=uninstrumented fun:wmemcmp=uninstrumented fun:wmemcpy=uninstrumented fun:wmemmove=uninstrumented fun:wmempcpy=uninstrumented fun:wmemset=uninstrumented fun:wordexp=uninstrumented fun:wordfree=uninstrumented fun:wprintf=uninstrumented fun:write=uninstrumented fun:writeColdStartFile=uninstrumented fun:writev=uninstrumented fun:wscanf=uninstrumented fun:xdecrypt=uninstrumented fun:xdr_accepted_reply=uninstrumented fun:xdr_array=uninstrumented fun:xdr_authdes_cred=uninstrumented fun:xdr_authdes_verf=uninstrumented fun:xdr_authunix_parms=uninstrumented fun:xdr_bool=uninstrumented fun:xdr_bytes=uninstrumented fun:xdr_callhdr=uninstrumented fun:xdr_callmsg=uninstrumented fun:xdr_cback_data=uninstrumented fun:xdr_char=uninstrumented fun:xdr_cryptkeyarg=uninstrumented fun:xdr_cryptkeyarg2=uninstrumented fun:xdr_cryptkeyres=uninstrumented fun:xdr_des_block=uninstrumented fun:xdr_domainname=uninstrumented fun:xdr_double=uninstrumented fun:xdr_enum=uninstrumented fun:xdr_float=uninstrumented fun:xdr_free=uninstrumented fun:xdr_getcredres=uninstrumented fun:xdr_hyper=uninstrumented fun:xdr_int=uninstrumented fun:xdr_int16_t=uninstrumented fun:xdr_int32_t=uninstrumented fun:xdr_int64_t=uninstrumented fun:xdr_int8_t=uninstrumented fun:xdr_key_netstarg=uninstrumented fun:xdr_key_netstres=uninstrumented fun:xdr_keybuf=uninstrumented fun:xdr_keydat=uninstrumented fun:xdr_keystatus=uninstrumented fun:xdr_long=uninstrumented fun:xdr_longlong_t=uninstrumented fun:xdr_mapname=uninstrumented fun:xdr_netnamestr=uninstrumented fun:xdr_netobj=uninstrumented fun:xdr_obj_p=uninstrumented fun:xdr_opaque=uninstrumented fun:xdr_opaque_auth=uninstrumented fun:xdr_peername=uninstrumented fun:xdr_pmap=uninstrumented fun:xdr_pmaplist=uninstrumented fun:xdr_pointer=uninstrumented fun:xdr_quad_t=uninstrumented fun:xdr_reference=uninstrumented fun:xdr_rejected_reply=uninstrumented fun:xdr_replymsg=uninstrumented fun:xdr_rmtcall_args=uninstrumented fun:xdr_rmtcallres=uninstrumented fun:xdr_short=uninstrumented fun:xdr_sizeof=uninstrumented fun:xdr_string=uninstrumented fun:xdr_u_char=uninstrumented fun:xdr_u_hyper=uninstrumented fun:xdr_u_int=uninstrumented fun:xdr_u_long=uninstrumented fun:xdr_u_longlong_t=uninstrumented fun:xdr_u_quad_t=uninstrumented fun:xdr_u_short=uninstrumented fun:xdr_uint16_t=uninstrumented fun:xdr_uint32_t=uninstrumented fun:xdr_uint64_t=uninstrumented fun:xdr_uint8_t=uninstrumented fun:xdr_union=uninstrumented fun:xdr_unixcred=uninstrumented fun:xdr_valdat=uninstrumented fun:xdr_vector=uninstrumented fun:xdr_void=uninstrumented fun:xdr_wrapstring=uninstrumented fun:xdr_yp_buf=uninstrumented fun:xdr_ypall=uninstrumented fun:xdr_ypbind_binding=uninstrumented fun:xdr_ypbind_resp=uninstrumented fun:xdr_ypbind_resptype=uninstrumented fun:xdr_ypbind_setdom=uninstrumented fun:xdr_ypdelete_args=uninstrumented fun:xdr_ypmap_parms=uninstrumented fun:xdr_ypmaplist=uninstrumented fun:xdr_yppush_status=uninstrumented fun:xdr_yppushresp_xfr=uninstrumented fun:xdr_ypreq_key=uninstrumented fun:xdr_ypreq_nokey=uninstrumented fun:xdr_ypreq_xfr=uninstrumented fun:xdr_ypresp_all=uninstrumented fun:xdr_ypresp_key_val=uninstrumented fun:xdr_ypresp_maplist=uninstrumented fun:xdr_ypresp_master=uninstrumented fun:xdr_ypresp_order=uninstrumented fun:xdr_ypresp_val=uninstrumented fun:xdr_ypresp_xfr=uninstrumented fun:xdr_ypstat=uninstrumented fun:xdr_ypupdate_args=uninstrumented fun:xdr_ypxfrstat=uninstrumented fun:xdrmem_create=uninstrumented fun:xdrrec_create=uninstrumented fun:xdrrec_endofrecord=uninstrumented fun:xdrrec_eof=uninstrumented fun:xdrrec_skiprecord=uninstrumented fun:xdrstdio_create=uninstrumented fun:xencrypt=uninstrumented fun:xprt_register=uninstrumented fun:xprt_unregister=uninstrumented fun:y0=uninstrumented fun:y0f=uninstrumented fun:y0f128=uninstrumented fun:y0f32=uninstrumented fun:y0f32x=uninstrumented fun:y0f64=uninstrumented fun:y0f64x=uninstrumented fun:y0l=uninstrumented fun:y1=uninstrumented fun:y1f=uninstrumented fun:y1f128=uninstrumented fun:y1f32=uninstrumented fun:y1f32x=uninstrumented fun:y1f64=uninstrumented fun:y1f64x=uninstrumented fun:y1l=uninstrumented fun:yn=uninstrumented fun:ynf=uninstrumented fun:ynf128=uninstrumented fun:ynf32=uninstrumented fun:ynf32x=uninstrumented fun:ynf64=uninstrumented fun:ynf64x=uninstrumented fun:ynl=uninstrumented fun:yp_all=uninstrumented fun:yp_bind=uninstrumented fun:yp_first=uninstrumented fun:yp_get_default_domain=uninstrumented fun:yp_maplist=uninstrumented fun:yp_master=uninstrumented fun:yp_match=uninstrumented fun:yp_next=uninstrumented fun:yp_order=uninstrumented fun:yp_unbind=uninstrumented fun:yp_update=uninstrumented fun:ypbinderr_string=uninstrumented fun:yperr_string=uninstrumented fun:ypprot_err=uninstrumented ================================================ FILE: runtime/dfsan/libc_ubuntu2204_abilist.txt ================================================ fun:_Exit=uninstrumented fun:_Fork=uninstrumented fun:_IO_adjust_column=uninstrumented fun:_IO_adjust_wcolumn=uninstrumented fun:_IO_default_doallocate=uninstrumented fun:_IO_default_finish=uninstrumented fun:_IO_default_pbackfail=uninstrumented fun:_IO_default_uflow=uninstrumented fun:_IO_default_xsgetn=uninstrumented fun:_IO_default_xsputn=uninstrumented fun:_IO_do_write=uninstrumented fun:_IO_doallocbuf=uninstrumented fun:_IO_enable_locks=uninstrumented fun:_IO_fclose=uninstrumented fun:_IO_fdopen=uninstrumented fun:_IO_feof=uninstrumented fun:_IO_ferror=uninstrumented fun:_IO_fflush=uninstrumented fun:_IO_fgetpos=uninstrumented fun:_IO_fgetpos64=uninstrumented fun:_IO_fgets=uninstrumented fun:_IO_file_attach=uninstrumented fun:_IO_file_close=uninstrumented fun:_IO_file_close_it=uninstrumented fun:_IO_file_doallocate=uninstrumented fun:_IO_file_finish=uninstrumented fun:_IO_file_fopen=uninstrumented fun:_IO_file_init=uninstrumented fun:_IO_file_open=uninstrumented fun:_IO_file_overflow=uninstrumented fun:_IO_file_read=uninstrumented fun:_IO_file_seek=uninstrumented fun:_IO_file_seekoff=uninstrumented fun:_IO_file_setbuf=uninstrumented fun:_IO_file_stat=uninstrumented fun:_IO_file_sync=uninstrumented fun:_IO_file_underflow=uninstrumented fun:_IO_file_write=uninstrumented fun:_IO_file_xsputn=uninstrumented fun:_IO_flockfile=uninstrumented fun:_IO_flush_all=uninstrumented fun:_IO_flush_all_linebuffered=uninstrumented fun:_IO_fopen=uninstrumented fun:_IO_fprintf=uninstrumented fun:_IO_fputs=uninstrumented fun:_IO_fread=uninstrumented fun:_IO_free_backup_area=uninstrumented fun:_IO_free_wbackup_area=uninstrumented fun:_IO_fsetpos=uninstrumented fun:_IO_fsetpos64=uninstrumented fun:_IO_ftell=uninstrumented fun:_IO_ftrylockfile=uninstrumented fun:_IO_funlockfile=uninstrumented fun:_IO_fwrite=uninstrumented fun:_IO_getc=uninstrumented fun:_IO_getline=uninstrumented fun:_IO_getline_info=uninstrumented fun:_IO_gets=uninstrumented fun:_IO_init=uninstrumented fun:_IO_init_marker=uninstrumented fun:_IO_init_wmarker=uninstrumented fun:_IO_iter_begin=uninstrumented fun:_IO_iter_end=uninstrumented fun:_IO_iter_file=uninstrumented fun:_IO_iter_next=uninstrumented fun:_IO_least_wmarker=uninstrumented fun:_IO_link_in=uninstrumented fun:_IO_list_lock=uninstrumented fun:_IO_list_resetlock=uninstrumented fun:_IO_list_unlock=uninstrumented fun:_IO_marker_delta=uninstrumented fun:_IO_marker_difference=uninstrumented fun:_IO_padn=uninstrumented fun:_IO_peekc_locked=uninstrumented fun:_IO_popen=uninstrumented fun:_IO_printf=uninstrumented fun:_IO_proc_close=uninstrumented fun:_IO_proc_open=uninstrumented fun:_IO_putc=uninstrumented fun:_IO_puts=uninstrumented fun:_IO_remove_marker=uninstrumented fun:_IO_seekmark=uninstrumented fun:_IO_seekoff=uninstrumented fun:_IO_seekpos=uninstrumented fun:_IO_seekwmark=uninstrumented fun:_IO_setb=uninstrumented fun:_IO_setbuffer=uninstrumented fun:_IO_setvbuf=uninstrumented fun:_IO_sgetn=uninstrumented fun:_IO_sprintf=uninstrumented fun:_IO_sputbackc=uninstrumented fun:_IO_sputbackwc=uninstrumented fun:_IO_sscanf=uninstrumented fun:_IO_str_init_readonly=uninstrumented fun:_IO_str_init_static=uninstrumented fun:_IO_str_overflow=uninstrumented fun:_IO_str_pbackfail=uninstrumented fun:_IO_str_seekoff=uninstrumented fun:_IO_str_underflow=uninstrumented fun:_IO_sungetc=uninstrumented fun:_IO_sungetwc=uninstrumented fun:_IO_switch_to_get_mode=uninstrumented fun:_IO_switch_to_main_wget_area=uninstrumented fun:_IO_switch_to_wbackup_area=uninstrumented fun:_IO_switch_to_wget_mode=uninstrumented fun:_IO_un_link=uninstrumented fun:_IO_ungetc=uninstrumented fun:_IO_unsave_markers=uninstrumented fun:_IO_unsave_wmarkers=uninstrumented fun:_IO_vfprintf=uninstrumented fun:_IO_vfscanf=uninstrumented fun:_IO_vsprintf=uninstrumented fun:_IO_wdefault_doallocate=uninstrumented fun:_IO_wdefault_finish=uninstrumented fun:_IO_wdefault_pbackfail=uninstrumented fun:_IO_wdefault_uflow=uninstrumented fun:_IO_wdefault_xsgetn=uninstrumented fun:_IO_wdefault_xsputn=uninstrumented fun:_IO_wdo_write=uninstrumented fun:_IO_wdoallocbuf=uninstrumented fun:_IO_wfile_overflow=uninstrumented fun:_IO_wfile_seekoff=uninstrumented fun:_IO_wfile_sync=uninstrumented fun:_IO_wfile_underflow=uninstrumented fun:_IO_wfile_xsputn=uninstrumented fun:_IO_wmarker_delta=uninstrumented fun:_IO_wsetb=uninstrumented fun:_Unwind_Backtrace=uninstrumented fun:_Unwind_DeleteException=uninstrumented fun:_Unwind_FindEnclosingFunction=uninstrumented fun:_Unwind_Find_FDE=uninstrumented fun:_Unwind_ForcedUnwind=uninstrumented fun:_Unwind_GetCFA=uninstrumented fun:_Unwind_GetDataRelBase=uninstrumented fun:_Unwind_GetGR=uninstrumented fun:_Unwind_GetIP=uninstrumented fun:_Unwind_GetIPInfo=uninstrumented fun:_Unwind_GetLanguageSpecificData=uninstrumented fun:_Unwind_GetRegionStart=uninstrumented fun:_Unwind_GetTextRelBase=uninstrumented fun:_Unwind_RaiseException=uninstrumented fun:_Unwind_Resume=uninstrumented fun:_Unwind_Resume_or_Rethrow=uninstrumented fun:_Unwind_SetGR=uninstrumented fun:_Unwind_SetIP=uninstrumented fun:__absvdi2=uninstrumented fun:__absvsi2=uninstrumented fun:__absvti2=uninstrumented fun:__acos_finite=uninstrumented fun:__acosf128_finite=uninstrumented fun:__acosf_finite=uninstrumented fun:__acosh_finite=uninstrumented fun:__acoshf128_finite=uninstrumented fun:__acoshf_finite=uninstrumented fun:__acoshl_finite=uninstrumented fun:__acosl_finite=uninstrumented fun:__addtf3=uninstrumented fun:__addvdi3=uninstrumented fun:__addvsi3=uninstrumented fun:__addvti3=uninstrumented fun:__adjtimex=uninstrumented fun:__arch_prctl=uninstrumented fun:__argz_count=uninstrumented fun:__argz_next=uninstrumented fun:__argz_stringify=uninstrumented fun:__ashlti3=uninstrumented fun:__ashrti3=uninstrumented fun:__asin_finite=uninstrumented fun:__asinf128_finite=uninstrumented fun:__asinf_finite=uninstrumented fun:__asinl_finite=uninstrumented fun:__asprintf=uninstrumented fun:__asprintf_chk=uninstrumented fun:__assert=uninstrumented fun:__assert_fail=uninstrumented fun:__assert_perror_fail=uninstrumented fun:__atan2_finite=uninstrumented fun:__atan2f128_finite=uninstrumented fun:__atan2f_finite=uninstrumented fun:__atan2l_finite=uninstrumented fun:__atanh_finite=uninstrumented fun:__atanhf128_finite=uninstrumented fun:__atanhf_finite=uninstrumented fun:__atanhl_finite=uninstrumented fun:__avx_resms64_12=uninstrumented fun:__avx_resms64_13=uninstrumented fun:__avx_resms64_14=uninstrumented fun:__avx_resms64_15=uninstrumented fun:__avx_resms64_16=uninstrumented fun:__avx_resms64_17=uninstrumented fun:__avx_resms64_18=uninstrumented fun:__avx_resms64f_12=uninstrumented fun:__avx_resms64f_13=uninstrumented fun:__avx_resms64f_14=uninstrumented fun:__avx_resms64f_15=uninstrumented fun:__avx_resms64f_16=uninstrumented fun:__avx_resms64f_17=uninstrumented fun:__avx_resms64fx_12=uninstrumented fun:__avx_resms64fx_13=uninstrumented fun:__avx_resms64fx_14=uninstrumented fun:__avx_resms64fx_15=uninstrumented fun:__avx_resms64fx_16=uninstrumented fun:__avx_resms64fx_17=uninstrumented fun:__avx_resms64x_12=uninstrumented fun:__avx_resms64x_13=uninstrumented fun:__avx_resms64x_14=uninstrumented fun:__avx_resms64x_15=uninstrumented fun:__avx_resms64x_16=uninstrumented fun:__avx_resms64x_17=uninstrumented fun:__avx_resms64x_18=uninstrumented fun:__avx_savms64_12=uninstrumented fun:__avx_savms64_13=uninstrumented fun:__avx_savms64_14=uninstrumented fun:__avx_savms64_15=uninstrumented fun:__avx_savms64_16=uninstrumented fun:__avx_savms64_17=uninstrumented fun:__avx_savms64_18=uninstrumented fun:__avx_savms64f_12=uninstrumented fun:__avx_savms64f_13=uninstrumented fun:__avx_savms64f_14=uninstrumented fun:__avx_savms64f_15=uninstrumented fun:__avx_savms64f_16=uninstrumented fun:__avx_savms64f_17=uninstrumented fun:__b64_ntop=uninstrumented fun:__b64_pton=uninstrumented fun:__backtrace=uninstrumented fun:__backtrace_symbols=uninstrumented fun:__backtrace_symbols_fd=uninstrumented fun:__bid128_abs=uninstrumented fun:__bid128_add=uninstrumented fun:__bid128_class=uninstrumented fun:__bid128_copy=uninstrumented fun:__bid128_copySign=uninstrumented fun:__bid128_div=uninstrumented fun:__bid128_fma=uninstrumented fun:__bid128_from_int32=uninstrumented fun:__bid128_from_int64=uninstrumented fun:__bid128_from_uint32=uninstrumented fun:__bid128_from_uint64=uninstrumented fun:__bid128_isCanonical=uninstrumented fun:__bid128_isFinite=uninstrumented fun:__bid128_isInf=uninstrumented fun:__bid128_isNaN=uninstrumented fun:__bid128_isNormal=uninstrumented fun:__bid128_isSignaling=uninstrumented fun:__bid128_isSigned=uninstrumented fun:__bid128_isSubnormal=uninstrumented fun:__bid128_isZero=uninstrumented fun:__bid128_mul=uninstrumented fun:__bid128_negate=uninstrumented fun:__bid128_quiet_equal=uninstrumented fun:__bid128_quiet_greater=uninstrumented fun:__bid128_quiet_greater_equal=uninstrumented fun:__bid128_quiet_greater_unordered=uninstrumented fun:__bid128_quiet_less=uninstrumented fun:__bid128_quiet_less_equal=uninstrumented fun:__bid128_quiet_less_unordered=uninstrumented fun:__bid128_quiet_not_equal=uninstrumented fun:__bid128_quiet_not_greater=uninstrumented fun:__bid128_quiet_not_less=uninstrumented fun:__bid128_quiet_ordered=uninstrumented fun:__bid128_quiet_unordered=uninstrumented fun:__bid128_radix=uninstrumented fun:__bid128_sameQuantum=uninstrumented fun:__bid128_signaling_greater=uninstrumented fun:__bid128_signaling_greater_equal=uninstrumented fun:__bid128_signaling_greater_unordered=uninstrumented fun:__bid128_signaling_less=uninstrumented fun:__bid128_signaling_less_equal=uninstrumented fun:__bid128_signaling_less_unordered=uninstrumented fun:__bid128_signaling_not_greater=uninstrumented fun:__bid128_signaling_not_less=uninstrumented fun:__bid128_sub=uninstrumented fun:__bid128_to_bid32=uninstrumented fun:__bid128_to_bid64=uninstrumented fun:__bid128_to_binary128=uninstrumented fun:__bid128_to_binary32=uninstrumented fun:__bid128_to_binary64=uninstrumented fun:__bid128_to_binary80=uninstrumented fun:__bid128_to_int32_ceil=uninstrumented fun:__bid128_to_int32_floor=uninstrumented fun:__bid128_to_int32_int=uninstrumented fun:__bid128_to_int32_rnint=uninstrumented fun:__bid128_to_int32_rninta=uninstrumented fun:__bid128_to_int32_xceil=uninstrumented fun:__bid128_to_int32_xfloor=uninstrumented fun:__bid128_to_int32_xint=uninstrumented fun:__bid128_to_int32_xrnint=uninstrumented fun:__bid128_to_int32_xrninta=uninstrumented fun:__bid128_to_int64_ceil=uninstrumented fun:__bid128_to_int64_floor=uninstrumented fun:__bid128_to_int64_int=uninstrumented fun:__bid128_to_int64_rnint=uninstrumented fun:__bid128_to_int64_rninta=uninstrumented fun:__bid128_to_int64_xceil=uninstrumented fun:__bid128_to_int64_xfloor=uninstrumented fun:__bid128_to_int64_xint=uninstrumented fun:__bid128_to_int64_xrnint=uninstrumented fun:__bid128_to_int64_xrninta=uninstrumented fun:__bid128_to_uint32_ceil=uninstrumented fun:__bid128_to_uint32_floor=uninstrumented fun:__bid128_to_uint32_int=uninstrumented fun:__bid128_to_uint32_rnint=uninstrumented fun:__bid128_to_uint32_rninta=uninstrumented fun:__bid128_to_uint32_xceil=uninstrumented fun:__bid128_to_uint32_xfloor=uninstrumented fun:__bid128_to_uint32_xint=uninstrumented fun:__bid128_to_uint32_xrnint=uninstrumented fun:__bid128_to_uint32_xrninta=uninstrumented fun:__bid128_to_uint64_ceil=uninstrumented fun:__bid128_to_uint64_floor=uninstrumented fun:__bid128_to_uint64_int=uninstrumented fun:__bid128_to_uint64_rnint=uninstrumented fun:__bid128_to_uint64_rninta=uninstrumented fun:__bid128_to_uint64_xceil=uninstrumented fun:__bid128_to_uint64_xfloor=uninstrumented fun:__bid128_to_uint64_xint=uninstrumented fun:__bid128_to_uint64_xrnint=uninstrumented fun:__bid128_to_uint64_xrninta=uninstrumented fun:__bid128_totalOrder=uninstrumented fun:__bid128_totalOrderMag=uninstrumented fun:__bid128dd_add=uninstrumented fun:__bid128dd_div=uninstrumented fun:__bid128dd_mul=uninstrumented fun:__bid128dd_sub=uninstrumented fun:__bid128ddd_fma=uninstrumented fun:__bid128ddq_fma=uninstrumented fun:__bid128dq_add=uninstrumented fun:__bid128dq_div=uninstrumented fun:__bid128dq_mul=uninstrumented fun:__bid128dq_sub=uninstrumented fun:__bid128dqd_fma=uninstrumented fun:__bid128dqq_fma=uninstrumented fun:__bid128qd_add=uninstrumented fun:__bid128qd_div=uninstrumented fun:__bid128qd_mul=uninstrumented fun:__bid128qd_sub=uninstrumented fun:__bid128qdd_fma=uninstrumented fun:__bid128qdq_fma=uninstrumented fun:__bid128qqd_fma=uninstrumented fun:__bid32_to_bid128=uninstrumented fun:__bid32_to_bid64=uninstrumented fun:__bid32_to_binary128=uninstrumented fun:__bid32_to_binary32=uninstrumented fun:__bid32_to_binary64=uninstrumented fun:__bid32_to_binary80=uninstrumented fun:__bid64_abs=uninstrumented fun:__bid64_add=uninstrumented fun:__bid64_class=uninstrumented fun:__bid64_copy=uninstrumented fun:__bid64_copySign=uninstrumented fun:__bid64_div=uninstrumented fun:__bid64_from_int32=uninstrumented fun:__bid64_from_int64=uninstrumented fun:__bid64_from_uint32=uninstrumented fun:__bid64_from_uint64=uninstrumented fun:__bid64_isCanonical=uninstrumented fun:__bid64_isFinite=uninstrumented fun:__bid64_isInf=uninstrumented fun:__bid64_isNaN=uninstrumented fun:__bid64_isNormal=uninstrumented fun:__bid64_isSignaling=uninstrumented fun:__bid64_isSigned=uninstrumented fun:__bid64_isSubnormal=uninstrumented fun:__bid64_isZero=uninstrumented fun:__bid64_mul=uninstrumented fun:__bid64_negate=uninstrumented fun:__bid64_quiet_equal=uninstrumented fun:__bid64_quiet_greater=uninstrumented fun:__bid64_quiet_greater_equal=uninstrumented fun:__bid64_quiet_greater_unordered=uninstrumented fun:__bid64_quiet_less=uninstrumented fun:__bid64_quiet_less_equal=uninstrumented fun:__bid64_quiet_less_unordered=uninstrumented fun:__bid64_quiet_not_equal=uninstrumented fun:__bid64_quiet_not_greater=uninstrumented fun:__bid64_quiet_not_less=uninstrumented fun:__bid64_quiet_ordered=uninstrumented fun:__bid64_quiet_unordered=uninstrumented fun:__bid64_radix=uninstrumented fun:__bid64_sameQuantum=uninstrumented fun:__bid64_signaling_greater=uninstrumented fun:__bid64_signaling_greater_equal=uninstrumented fun:__bid64_signaling_greater_unordered=uninstrumented fun:__bid64_signaling_less=uninstrumented fun:__bid64_signaling_less_equal=uninstrumented fun:__bid64_signaling_less_unordered=uninstrumented fun:__bid64_signaling_not_greater=uninstrumented fun:__bid64_signaling_not_less=uninstrumented fun:__bid64_sub=uninstrumented fun:__bid64_to_bid128=uninstrumented fun:__bid64_to_bid32=uninstrumented fun:__bid64_to_binary128=uninstrumented fun:__bid64_to_binary32=uninstrumented fun:__bid64_to_binary64=uninstrumented fun:__bid64_to_binary80=uninstrumented fun:__bid64_to_int32_ceil=uninstrumented fun:__bid64_to_int32_floor=uninstrumented fun:__bid64_to_int32_int=uninstrumented fun:__bid64_to_int32_rnint=uninstrumented fun:__bid64_to_int32_rninta=uninstrumented fun:__bid64_to_int32_xceil=uninstrumented fun:__bid64_to_int32_xfloor=uninstrumented fun:__bid64_to_int32_xint=uninstrumented fun:__bid64_to_int32_xrnint=uninstrumented fun:__bid64_to_int32_xrninta=uninstrumented fun:__bid64_to_int64_ceil=uninstrumented fun:__bid64_to_int64_floor=uninstrumented fun:__bid64_to_int64_int=uninstrumented fun:__bid64_to_int64_rnint=uninstrumented fun:__bid64_to_int64_rninta=uninstrumented fun:__bid64_to_int64_xceil=uninstrumented fun:__bid64_to_int64_xfloor=uninstrumented fun:__bid64_to_int64_xint=uninstrumented fun:__bid64_to_int64_xrnint=uninstrumented fun:__bid64_to_int64_xrninta=uninstrumented fun:__bid64_to_uint32_ceil=uninstrumented fun:__bid64_to_uint32_floor=uninstrumented fun:__bid64_to_uint32_int=uninstrumented fun:__bid64_to_uint32_rnint=uninstrumented fun:__bid64_to_uint32_rninta=uninstrumented fun:__bid64_to_uint32_xceil=uninstrumented fun:__bid64_to_uint32_xfloor=uninstrumented fun:__bid64_to_uint32_xint=uninstrumented fun:__bid64_to_uint32_xrnint=uninstrumented fun:__bid64_to_uint32_xrninta=uninstrumented fun:__bid64_to_uint64_ceil=uninstrumented fun:__bid64_to_uint64_floor=uninstrumented fun:__bid64_to_uint64_int=uninstrumented fun:__bid64_to_uint64_rnint=uninstrumented fun:__bid64_to_uint64_rninta=uninstrumented fun:__bid64_to_uint64_xceil=uninstrumented fun:__bid64_to_uint64_xfloor=uninstrumented fun:__bid64_to_uint64_xint=uninstrumented fun:__bid64_to_uint64_xrnint=uninstrumented fun:__bid64_to_uint64_xrninta=uninstrumented fun:__bid64_totalOrder=uninstrumented fun:__bid64_totalOrderMag=uninstrumented fun:__bid64ddq_fma=uninstrumented fun:__bid64dq_add=uninstrumented fun:__bid64dq_div=uninstrumented fun:__bid64dq_mul=uninstrumented fun:__bid64dq_sub=uninstrumented fun:__bid64dqd_fma=uninstrumented fun:__bid64dqq_fma=uninstrumented fun:__bid64qd_add=uninstrumented fun:__bid64qd_div=uninstrumented fun:__bid64qd_mul=uninstrumented fun:__bid64qd_sub=uninstrumented fun:__bid64qdd_fma=uninstrumented fun:__bid64qdq_fma=uninstrumented fun:__bid64qq_add=uninstrumented fun:__bid64qq_div=uninstrumented fun:__bid64qq_mul=uninstrumented fun:__bid64qq_sub=uninstrumented fun:__bid64qqd_fma=uninstrumented fun:__bid64qqq_fma=uninstrumented fun:__bid_adddd3=uninstrumented fun:__bid_addsd3=uninstrumented fun:__bid_addtd3=uninstrumented fun:__bid_divdd3=uninstrumented fun:__bid_divsd3=uninstrumented fun:__bid_divtd3=uninstrumented fun:__bid_eqdd2=uninstrumented fun:__bid_eqsd2=uninstrumented fun:__bid_eqtd2=uninstrumented fun:__bid_extendddtd2=uninstrumented fun:__bid_extendddtf=uninstrumented fun:__bid_extendddxf=uninstrumented fun:__bid_extenddfdd=uninstrumented fun:__bid_extenddftd=uninstrumented fun:__bid_extendsddd2=uninstrumented fun:__bid_extendsddf=uninstrumented fun:__bid_extendsdtd2=uninstrumented fun:__bid_extendsdtf=uninstrumented fun:__bid_extendsdxf=uninstrumented fun:__bid_extendsfdd=uninstrumented fun:__bid_extendsfsd=uninstrumented fun:__bid_extendsftd=uninstrumented fun:__bid_extendtftd=uninstrumented fun:__bid_extendxftd=uninstrumented fun:__bid_fixdddi=uninstrumented fun:__bid_fixddsi=uninstrumented fun:__bid_fixsddi=uninstrumented fun:__bid_fixsdsi=uninstrumented fun:__bid_fixtddi=uninstrumented fun:__bid_fixtdsi=uninstrumented fun:__bid_fixunsdddi=uninstrumented fun:__bid_fixunsddsi=uninstrumented fun:__bid_fixunssddi=uninstrumented fun:__bid_fixunssdsi=uninstrumented fun:__bid_fixunstddi=uninstrumented fun:__bid_fixunstdsi=uninstrumented fun:__bid_floatdidd=uninstrumented fun:__bid_floatdisd=uninstrumented fun:__bid_floatditd=uninstrumented fun:__bid_floatsidd=uninstrumented fun:__bid_floatsisd=uninstrumented fun:__bid_floatsitd=uninstrumented fun:__bid_floatunsdidd=uninstrumented fun:__bid_floatunsdisd=uninstrumented fun:__bid_floatunsditd=uninstrumented fun:__bid_floatunssidd=uninstrumented fun:__bid_floatunssisd=uninstrumented fun:__bid_floatunssitd=uninstrumented fun:__bid_gedd2=uninstrumented fun:__bid_gesd2=uninstrumented fun:__bid_getd2=uninstrumented fun:__bid_gtdd2=uninstrumented fun:__bid_gtsd2=uninstrumented fun:__bid_gttd2=uninstrumented fun:__bid_ledd2=uninstrumented fun:__bid_lesd2=uninstrumented fun:__bid_letd2=uninstrumented fun:__bid_ltdd2=uninstrumented fun:__bid_ltsd2=uninstrumented fun:__bid_lttd2=uninstrumented fun:__bid_muldd3=uninstrumented fun:__bid_mulsd3=uninstrumented fun:__bid_multd3=uninstrumented fun:__bid_nedd2=uninstrumented fun:__bid_nesd2=uninstrumented fun:__bid_netd2=uninstrumented fun:__bid_round128_19_38=uninstrumented fun:__bid_round192_39_57=uninstrumented fun:__bid_round256_58_76=uninstrumented fun:__bid_round64_2_18=uninstrumented fun:__bid_subdd3=uninstrumented fun:__bid_subsd3=uninstrumented fun:__bid_subtd3=uninstrumented fun:__bid_truncdddf=uninstrumented fun:__bid_truncddsd2=uninstrumented fun:__bid_truncddsf=uninstrumented fun:__bid_truncdfsd=uninstrumented fun:__bid_truncsdsf=uninstrumented fun:__bid_trunctddd2=uninstrumented fun:__bid_trunctddf=uninstrumented fun:__bid_trunctdsd2=uninstrumented fun:__bid_trunctdsf=uninstrumented fun:__bid_trunctdtf=uninstrumented fun:__bid_trunctdxf=uninstrumented fun:__bid_trunctfdd=uninstrumented fun:__bid_trunctfsd=uninstrumented fun:__bid_truncxfdd=uninstrumented fun:__bid_truncxfsd=uninstrumented fun:__bid_unorddd2=uninstrumented fun:__bid_unordsd2=uninstrumented fun:__bid_unordtd2=uninstrumented fun:__binary128_to_bid128=uninstrumented fun:__binary128_to_bid32=uninstrumented fun:__binary128_to_bid64=uninstrumented fun:__binary32_to_bid128=uninstrumented fun:__binary32_to_bid32=uninstrumented fun:__binary32_to_bid64=uninstrumented fun:__binary64_to_bid128=uninstrumented fun:__binary64_to_bid32=uninstrumented fun:__binary64_to_bid64=uninstrumented fun:__binary80_to_bid128=uninstrumented fun:__binary80_to_bid32=uninstrumented fun:__binary80_to_bid64=uninstrumented fun:__bsd_getpgrp=uninstrumented fun:__bswapdi2=uninstrumented fun:__bswapsi2=uninstrumented fun:__bzero=uninstrumented fun:__call_tls_dtors=uninstrumented fun:__chk_fail=uninstrumented fun:__clear_cache=uninstrumented fun:__clock_gettime=uninstrumented fun:__clog10=uninstrumented fun:__clog10f=uninstrumented fun:__clog10l=uninstrumented fun:__clone=uninstrumented fun:__close=uninstrumented fun:__close_nocancel=uninstrumented fun:__clrsbdi2=uninstrumented fun:__clrsbti2=uninstrumented fun:__clzdi2=uninstrumented fun:__clzti2=uninstrumented fun:__cmpti2=uninstrumented fun:__cmsg_nxthdr=uninstrumented fun:__confstr_chk=uninstrumented fun:__connect=uninstrumented fun:__copy_grp=uninstrumented fun:__cosh_finite=uninstrumented fun:__coshf128_finite=uninstrumented fun:__coshf_finite=uninstrumented fun:__coshl_finite=uninstrumented fun:__cpu_indicator_init=uninstrumented fun:__create_ib_request=uninstrumented fun:__ctype_b_loc=uninstrumented fun:__ctype_get_mb_cur_max=uninstrumented fun:__ctype_init=uninstrumented fun:__ctype_tolower_loc=uninstrumented fun:__ctype_toupper_loc=uninstrumented fun:__ctzdi2=uninstrumented fun:__ctzti2=uninstrumented fun:__cxa_at_quick_exit=uninstrumented fun:__cxa_atexit=uninstrumented fun:__cxa_finalize=uninstrumented fun:__cxa_thread_atexit_impl=uninstrumented fun:__cyg_profile_func_enter=uninstrumented fun:__cyg_profile_func_exit=uninstrumented fun:__dcgettext=uninstrumented fun:__default_morecore=uninstrumented fun:__deregister_frame=uninstrumented fun:__deregister_frame_info=uninstrumented fun:__deregister_frame_info_bases=uninstrumented fun:__dfp_clear_except=uninstrumented fun:__dfp_get_round=uninstrumented fun:__dfp_raise_except=uninstrumented fun:__dfp_set_round=uninstrumented fun:__dfp_test_except=uninstrumented fun:__dgettext=uninstrumented fun:__divdc3=uninstrumented fun:__divhc3=uninstrumented fun:__divmodti4=uninstrumented fun:__divsc3=uninstrumented fun:__divtc3=uninstrumented fun:__divtf3=uninstrumented fun:__divti3=uninstrumented fun:__divxc3=uninstrumented fun:__dn_comp=uninstrumented fun:__dn_count_labels=uninstrumented fun:__dn_expand=uninstrumented fun:__dn_skipname=uninstrumented fun:__do_niscall3=uninstrumented fun:__dprintf_chk=uninstrumented fun:__dup2=uninstrumented fun:__duplocale=uninstrumented fun:__emutls_get_address=uninstrumented fun:__emutls_register_common=uninstrumented fun:__enable_execute_stack=uninstrumented fun:__endmntent=uninstrumented fun:__eprintf=uninstrumented fun:__eqhf2=uninstrumented fun:__eqtf2=uninstrumented fun:__errno_location=uninstrumented fun:__exp10_finite=uninstrumented fun:__exp10f128_finite=uninstrumented fun:__exp10f_finite=uninstrumented fun:__exp10l_finite=uninstrumented fun:__exp2_finite=uninstrumented fun:__exp2f128_finite=uninstrumented fun:__exp2f_finite=uninstrumented fun:__exp2l_finite=uninstrumented fun:__exp_finite=uninstrumented fun:__expf128_finite=uninstrumented fun:__expf_finite=uninstrumented fun:__expl_finite=uninstrumented fun:__explicit_bzero_chk=uninstrumented fun:__extenddftf2=uninstrumented fun:__extendhfdf2=uninstrumented fun:__extendhfsf2=uninstrumented fun:__extendhftf2=uninstrumented fun:__extendhfxf2=uninstrumented fun:__extendsfdf2=uninstrumented fun:__extendsftf2=uninstrumented fun:__extendxftf2=uninstrumented fun:__fbufsize=uninstrumented fun:__fcntl=uninstrumented fun:__fdelt_chk=uninstrumented fun:__fdelt_warn=uninstrumented fun:__fentry__=uninstrumented fun:__ffs=uninstrumented fun:__ffsdi2=uninstrumented fun:__ffsti2=uninstrumented fun:__fgets_chk=uninstrumented fun:__fgets_unlocked_chk=uninstrumented fun:__fgetws_chk=uninstrumented fun:__fgetws_unlocked_chk=uninstrumented fun:__file_change_detection_for_fp=uninstrumented fun:__file_change_detection_for_path=uninstrumented fun:__file_change_detection_for_stat=uninstrumented fun:__file_is_unchanged=uninstrumented fun:__finite=uninstrumented fun:__finitef=uninstrumented fun:__finitef128=uninstrumented fun:__finitel=uninstrumented fun:__fixdfti=uninstrumented fun:__fixhfti=uninstrumented fun:__fixsfti=uninstrumented fun:__fixtfdi=uninstrumented fun:__fixtfsi=uninstrumented fun:__fixtfti=uninstrumented fun:__fixunsdfdi=uninstrumented fun:__fixunsdfti=uninstrumented fun:__fixunshfti=uninstrumented fun:__fixunssfdi=uninstrumented fun:__fixunssfti=uninstrumented fun:__fixunstfdi=uninstrumented fun:__fixunstfsi=uninstrumented fun:__fixunstfti=uninstrumented fun:__fixunsxfdi=uninstrumented fun:__fixunsxfti=uninstrumented fun:__fixxfti=uninstrumented fun:__flbf=uninstrumented fun:__floatditf=uninstrumented fun:__floatsitf=uninstrumented fun:__floattidf=uninstrumented fun:__floattihf=uninstrumented fun:__floattisf=uninstrumented fun:__floattitf=uninstrumented fun:__floattixf=uninstrumented fun:__floatunditf=uninstrumented fun:__floatunsitf=uninstrumented fun:__floatuntidf=uninstrumented fun:__floatuntihf=uninstrumented fun:__floatuntisf=uninstrumented fun:__floatuntitf=uninstrumented fun:__floatuntixf=uninstrumented fun:__fmod_finite=uninstrumented fun:__fmodf128_finite=uninstrumented fun:__fmodf_finite=uninstrumented fun:__fmodl_finite=uninstrumented fun:__follow_path=uninstrumented fun:__fork=uninstrumented fun:__fortify_fail=uninstrumented fun:__fp_nquery=uninstrumented fun:__fp_query=uninstrumented fun:__fp_resstat=uninstrumented fun:__fpclassify=uninstrumented fun:__fpclassifyf=uninstrumented fun:__fpclassifyf128=uninstrumented fun:__fpclassifyl=uninstrumented fun:__fpending=uninstrumented fun:__fprintf_chk=uninstrumented fun:__fpurge=uninstrumented fun:__fread_chk=uninstrumented fun:__fread_unlocked_chk=uninstrumented fun:__freadable=uninstrumented fun:__freading=uninstrumented fun:__free_fdresult=uninstrumented fun:__freelocale=uninstrumented fun:__fseeko64=uninstrumented fun:__fsetlocking=uninstrumented fun:__fstat64=uninstrumented fun:__ftello64=uninstrumented fun:__fwprintf_chk=uninstrumented fun:__fwritable=uninstrumented fun:__fwriting=uninstrumented fun:__fxstat=uninstrumented fun:__fxstat64=uninstrumented fun:__fxstatat=uninstrumented fun:__fxstatat64=uninstrumented fun:__gamma_r_finite=uninstrumented fun:__gammaf128_r_finite=uninstrumented fun:__gammaf_r_finite=uninstrumented fun:__gammal_r_finite=uninstrumented fun:__gcc_bcmp=uninstrumented fun:__gcc_personality_v0=uninstrumented fun:__gconv_create_spec=uninstrumented fun:__gconv_destroy_spec=uninstrumented fun:__gconv_get_alias_db=uninstrumented fun:__gconv_get_cache=uninstrumented fun:__gconv_get_modules_db=uninstrumented fun:__gconv_open=uninstrumented fun:__gconv_transliterate=uninstrumented fun:__generic_findstack=uninstrumented fun:__generic_morestack=uninstrumented fun:__generic_morestack_set_initial_sp=uninstrumented fun:__generic_releasestack=uninstrumented fun:__getauxval=uninstrumented fun:__getcwd_chk=uninstrumented fun:__getdelim=uninstrumented fun:__getdomainname_chk=uninstrumented fun:__getf2=uninstrumented fun:__getgroups_chk=uninstrumented fun:__gethostname_chk=uninstrumented fun:__getlogin_r_chk=uninstrumented fun:__getmntent_r=uninstrumented fun:__getpagesize=uninstrumented fun:__getpgid=uninstrumented fun:__getpid=uninstrumented fun:__getrlimit=uninstrumented fun:__gets_chk=uninstrumented fun:__gettimeofday=uninstrumented fun:__getwd_chk=uninstrumented fun:__gmtime_r=uninstrumented fun:__gttf2=uninstrumented fun:__h_errno_location=uninstrumented fun:__hostalias=uninstrumented fun:__hypot_finite=uninstrumented fun:__hypotf128_finite=uninstrumented fun:__hypotf_finite=uninstrumented fun:__hypotl_finite=uninstrumented fun:__idna_from_dns_encoding=uninstrumented fun:__idna_to_dns_encoding=uninstrumented fun:__inet6_scopeid_pton=uninstrumented fun:__inet_aton_exact=uninstrumented fun:__inet_pton_length=uninstrumented fun:__internal_endnetgrent=uninstrumented fun:__internal_getnetgrent_r=uninstrumented fun:__internal_setnetgrent=uninstrumented fun:__isalnum_l=uninstrumented fun:__isalpha_l=uninstrumented fun:__isascii_l=uninstrumented fun:__isblank_l=uninstrumented fun:__iscanonicall=uninstrumented fun:__iscntrl_l=uninstrumented fun:__isctype=uninstrumented fun:__isdigit_l=uninstrumented fun:__iseqsig=uninstrumented fun:__iseqsigf=uninstrumented fun:__iseqsigf128=uninstrumented fun:__iseqsigl=uninstrumented fun:__isgraph_l=uninstrumented fun:__isinf=uninstrumented fun:__isinff=uninstrumented fun:__isinff128=uninstrumented fun:__isinfl=uninstrumented fun:__islower_l=uninstrumented fun:__isnan=uninstrumented fun:__isnanf=uninstrumented fun:__isnanf128=uninstrumented fun:__isnanl=uninstrumented fun:__isoc99_fscanf=uninstrumented fun:__isoc99_fwscanf=uninstrumented fun:__isoc99_scanf=uninstrumented fun:__isoc99_sscanf=uninstrumented fun:__isoc99_swscanf=uninstrumented fun:__isoc99_vfscanf=uninstrumented fun:__isoc99_vfwscanf=uninstrumented fun:__isoc99_vscanf=uninstrumented fun:__isoc99_vsscanf=uninstrumented fun:__isoc99_vswscanf=uninstrumented fun:__isoc99_vwscanf=uninstrumented fun:__isoc99_wscanf=uninstrumented fun:__isprint_l=uninstrumented fun:__ispunct_l=uninstrumented fun:__issignaling=uninstrumented fun:__issignalingf=uninstrumented fun:__issignalingf128=uninstrumented fun:__issignalingl=uninstrumented fun:__isspace_l=uninstrumented fun:__isupper_l=uninstrumented fun:__iswalnum_l=uninstrumented fun:__iswalpha_l=uninstrumented fun:__iswblank_l=uninstrumented fun:__iswcntrl_l=uninstrumented fun:__iswctype=uninstrumented fun:__iswctype_l=uninstrumented fun:__iswdigit_l=uninstrumented fun:__iswgraph_l=uninstrumented fun:__iswlower_l=uninstrumented fun:__iswprint_l=uninstrumented fun:__iswpunct_l=uninstrumented fun:__iswspace_l=uninstrumented fun:__iswupper_l=uninstrumented fun:__iswxdigit_l=uninstrumented fun:__isxdigit_l=uninstrumented fun:__ivaliduser=uninstrumented fun:__j0_finite=uninstrumented fun:__j0f128_finite=uninstrumented fun:__j0f_finite=uninstrumented fun:__j0l_finite=uninstrumented fun:__j1_finite=uninstrumented fun:__j1f128_finite=uninstrumented fun:__j1f_finite=uninstrumented fun:__j1l_finite=uninstrumented fun:__jn_finite=uninstrumented fun:__jnf128_finite=uninstrumented fun:__jnf_finite=uninstrumented fun:__jnl_finite=uninstrumented fun:__letf2=uninstrumented fun:__lgamma_r_finite=uninstrumented fun:__lgammaf128_r_finite=uninstrumented fun:__lgammaf_r_finite=uninstrumented fun:__lgammal_r_finite=uninstrumented fun:__libanl_version_placeholder=uninstrumented fun:__libc_alloc_buffer_alloc_array=uninstrumented fun:__libc_alloc_buffer_allocate=uninstrumented fun:__libc_alloc_buffer_copy_bytes=uninstrumented fun:__libc_alloc_buffer_copy_string=uninstrumented fun:__libc_alloc_buffer_create_failure=uninstrumented fun:__libc_alloca_cutoff=uninstrumented fun:__libc_allocate_once_slow=uninstrumented fun:__libc_allocate_rtsig=uninstrumented fun:__libc_calloc=uninstrumented fun:__libc_clntudp_bufcreate=uninstrumented fun:__libc_current_sigrtmax=uninstrumented fun:__libc_current_sigrtmin=uninstrumented fun:__libc_dn_expand=uninstrumented fun:__libc_dn_skipname=uninstrumented fun:__libc_dynarray_at_failure=uninstrumented fun:__libc_dynarray_emplace_enlarge=uninstrumented fun:__libc_dynarray_finalize=uninstrumented fun:__libc_dynarray_resize=uninstrumented fun:__libc_dynarray_resize_clear=uninstrumented fun:__libc_early_init=uninstrumented fun:__libc_fatal=uninstrumented fun:__libc_fcntl64=uninstrumented fun:__libc_fork=uninstrumented fun:__libc_free=uninstrumented fun:__libc_freeres=uninstrumented fun:__libc_ifunc_impl_list=uninstrumented fun:__libc_init_first=uninstrumented fun:__libc_mallinfo=uninstrumented fun:__libc_malloc=uninstrumented fun:__libc_mallopt=uninstrumented fun:__libc_memalign=uninstrumented fun:__libc_msgrcv=uninstrumented fun:__libc_msgsnd=uninstrumented fun:__libc_ns_makecanon=uninstrumented fun:__libc_ns_samename=uninstrumented fun:__libc_pread=uninstrumented fun:__libc_pvalloc=uninstrumented fun:__libc_pwrite=uninstrumented fun:__libc_realloc=uninstrumented fun:__libc_reallocarray=uninstrumented fun:__libc_res_dnok=uninstrumented fun:__libc_res_hnok=uninstrumented fun:__libc_res_nameinquery=uninstrumented fun:__libc_res_queriesmatch=uninstrumented fun:__libc_rpc_getport=uninstrumented fun:__libc_sa_len=uninstrumented fun:__libc_scratch_buffer_dupfree=uninstrumented fun:__libc_scratch_buffer_grow=uninstrumented fun:__libc_scratch_buffer_grow_preserve=uninstrumented fun:__libc_scratch_buffer_set_array_size=uninstrumented fun:__libc_secure_getenv=uninstrumented fun:__libc_sigaction=uninstrumented fun:__libc_start_main=uninstrumented fun:__libc_system=uninstrumented fun:__libc_unwind_link_get=uninstrumented fun:__libc_valloc=uninstrumented fun:__libdl_version_placeholder=uninstrumented fun:__libpthread_version_placeholder=uninstrumented fun:__librt_version_placeholder=uninstrumented fun:__libutil_version_placeholder=uninstrumented fun:__lll_lock_wait_private=uninstrumented fun:__lll_lock_wake_private=uninstrumented fun:__loc_aton=uninstrumented fun:__loc_ntoa=uninstrumented fun:__log10_finite=uninstrumented fun:__log10f128_finite=uninstrumented fun:__log10f_finite=uninstrumented fun:__log10l_finite=uninstrumented fun:__log2_finite=uninstrumented fun:__log2f128_finite=uninstrumented fun:__log2f_finite=uninstrumented fun:__log2l_finite=uninstrumented fun:__log_finite=uninstrumented fun:__logf128_finite=uninstrumented fun:__logf_finite=uninstrumented fun:__logl_finite=uninstrumented fun:__longjmp_chk=uninstrumented fun:__lseek=uninstrumented fun:__lshrti3=uninstrumented fun:__lttf2=uninstrumented fun:__lxstat=uninstrumented fun:__lxstat64=uninstrumented fun:__madvise=uninstrumented fun:__mbrlen=uninstrumented fun:__mbrtowc=uninstrumented fun:__mbsnrtowcs_chk=uninstrumented fun:__mbsrtowcs_chk=uninstrumented fun:__mbstowcs_chk=uninstrumented fun:__memcmpeq=uninstrumented fun:__memcpy_chk=uninstrumented fun:__memmove_chk=uninstrumented fun:__mempcpy=uninstrumented fun:__mempcpy_chk=uninstrumented fun:__mempcpy_small=uninstrumented fun:__memset_chk=uninstrumented fun:__merge_grp=uninstrumented fun:__mktemp=uninstrumented fun:__mmap=uninstrumented fun:__modti3=uninstrumented fun:__monstartup=uninstrumented fun:__morestack=uninstrumented fun:__morestack_allocate_stack_space=uninstrumented fun:__morestack_block_signals=uninstrumented fun:__morestack_fail=uninstrumented fun:__morestack_get_guard=uninstrumented fun:__morestack_large_model=uninstrumented fun:__morestack_load_mmap=uninstrumented fun:__morestack_make_guard=uninstrumented fun:__morestack_non_split=uninstrumented fun:__morestack_release_segments=uninstrumented fun:__morestack_set_guard=uninstrumented fun:__morestack_unblock_signals=uninstrumented fun:__mprotect=uninstrumented fun:__mq_open_2=uninstrumented fun:__muldc3=uninstrumented fun:__mulhc3=uninstrumented fun:__mulsc3=uninstrumented fun:__multc3=uninstrumented fun:__multf3=uninstrumented fun:__multi3=uninstrumented fun:__mulvdi3=uninstrumented fun:__mulvsi3=uninstrumented fun:__mulvti3=uninstrumented fun:__mulxc3=uninstrumented fun:__munmap=uninstrumented fun:__nanosleep=uninstrumented fun:__negtf2=uninstrumented fun:__negti2=uninstrumented fun:__negvdi2=uninstrumented fun:__negvsi2=uninstrumented fun:__negvti2=uninstrumented fun:__nehf2=uninstrumented fun:__netf2=uninstrumented fun:__netlink_assert_response=uninstrumented fun:__newlocale=uninstrumented fun:__nis_default_access=uninstrumented fun:__nis_default_group=uninstrumented fun:__nis_default_owner=uninstrumented fun:__nis_default_ttl=uninstrumented fun:__nis_finddirectory=uninstrumented fun:__nis_hash=uninstrumented fun:__nisbind_connect=uninstrumented fun:__nisbind_create=uninstrumented fun:__nisbind_destroy=uninstrumented fun:__nisbind_next=uninstrumented fun:__nl_langinfo_l=uninstrumented fun:__nptl_change_stack_perm=uninstrumented fun:__nptl_create_event=uninstrumented fun:__nptl_death_event=uninstrumented fun:__ns_get16=uninstrumented fun:__ns_get32=uninstrumented fun:__ns_name_compress=uninstrumented fun:__ns_name_ntop=uninstrumented fun:__ns_name_pack=uninstrumented fun:__ns_name_pton=uninstrumented fun:__ns_name_skip=uninstrumented fun:__ns_name_uncompress=uninstrumented fun:__ns_name_unpack=uninstrumented fun:__nss_configure_lookup=uninstrumented fun:__nss_database_get=uninstrumented fun:__nss_database_lookup=uninstrumented fun:__nss_disable_nscd=uninstrumented fun:__nss_files_data_endent=uninstrumented fun:__nss_files_data_open=uninstrumented fun:__nss_files_data_put=uninstrumented fun:__nss_files_data_setent=uninstrumented fun:__nss_files_fopen=uninstrumented fun:__nss_group_lookup=uninstrumented fun:__nss_group_lookup2=uninstrumented fun:__nss_hash=uninstrumented fun:__nss_hostname_digits_dots=uninstrumented fun:__nss_hosts_lookup=uninstrumented fun:__nss_hosts_lookup2=uninstrumented fun:__nss_lookup=uninstrumented fun:__nss_lookup_function=uninstrumented fun:__nss_next=uninstrumented fun:__nss_next2=uninstrumented fun:__nss_parse_line_result=uninstrumented fun:__nss_passwd_lookup=uninstrumented fun:__nss_passwd_lookup2=uninstrumented fun:__nss_readline=uninstrumented fun:__nss_services_lookup2=uninstrumented fun:__obstack_printf_chk=uninstrumented fun:__obstack_vprintf_chk=uninstrumented fun:__open=uninstrumented fun:__open64=uninstrumented fun:__open64_2=uninstrumented fun:__open64_nocancel=uninstrumented fun:__open_2=uninstrumented fun:__open_catalog=uninstrumented fun:__open_nocancel=uninstrumented fun:__openat64_2=uninstrumented fun:__openat_2=uninstrumented fun:__overflow=uninstrumented fun:__p_cdname=uninstrumented fun:__p_cdnname=uninstrumented fun:__p_class=uninstrumented fun:__p_fqname=uninstrumented fun:__p_fqnname=uninstrumented fun:__p_option=uninstrumented fun:__p_query=uninstrumented fun:__p_rcode=uninstrumented fun:__p_secstodate=uninstrumented fun:__p_time=uninstrumented fun:__p_type=uninstrumented fun:__paritydi2=uninstrumented fun:__parityti2=uninstrumented fun:__pipe=uninstrumented fun:__poll=uninstrumented fun:__poll_chk=uninstrumented fun:__popcountdi2=uninstrumented fun:__popcountti2=uninstrumented fun:__posix_getopt=uninstrumented fun:__pow_finite=uninstrumented fun:__powf128_finite=uninstrumented fun:__powf_finite=uninstrumented fun:__powidf2=uninstrumented fun:__powisf2=uninstrumented fun:__powitf2=uninstrumented fun:__powixf2=uninstrumented fun:__powl_finite=uninstrumented fun:__ppoll_chk=uninstrumented fun:__pread64=uninstrumented fun:__pread64_chk=uninstrumented fun:__pread64_nocancel=uninstrumented fun:__pread_chk=uninstrumented fun:__prepare_niscall=uninstrumented fun:__printf_chk=uninstrumented fun:__printf_fp=uninstrumented fun:__profile_frequency=uninstrumented fun:__pthread_atfork=uninstrumented fun:__pthread_cleanup_routine=uninstrumented fun:__pthread_get_minstack=uninstrumented fun:__pthread_getspecific=uninstrumented fun:__pthread_key_create=uninstrumented fun:__pthread_mutex_destroy=uninstrumented fun:__pthread_mutex_init=uninstrumented fun:__pthread_mutex_lock=uninstrumented fun:__pthread_mutex_trylock=uninstrumented fun:__pthread_mutex_unlock=uninstrumented fun:__pthread_mutexattr_destroy=uninstrumented fun:__pthread_mutexattr_init=uninstrumented fun:__pthread_mutexattr_settype=uninstrumented fun:__pthread_once=uninstrumented fun:__pthread_register_cancel=uninstrumented fun:__pthread_register_cancel_defer=uninstrumented fun:__pthread_rwlock_destroy=uninstrumented fun:__pthread_rwlock_init=uninstrumented fun:__pthread_rwlock_rdlock=uninstrumented fun:__pthread_rwlock_tryrdlock=uninstrumented fun:__pthread_rwlock_trywrlock=uninstrumented fun:__pthread_rwlock_unlock=uninstrumented fun:__pthread_rwlock_wrlock=uninstrumented fun:__pthread_setspecific=uninstrumented fun:__pthread_unregister_cancel=uninstrumented fun:__pthread_unregister_cancel_restore=uninstrumented fun:__pthread_unwind_next=uninstrumented fun:__ptsname_r_chk=uninstrumented fun:__putlong=uninstrumented fun:__putshort=uninstrumented fun:__pwrite64=uninstrumented fun:__rawmemchr=uninstrumented fun:__read=uninstrumented fun:__read_chk=uninstrumented fun:__read_nocancel=uninstrumented fun:__readlink_chk=uninstrumented fun:__readlinkat_chk=uninstrumented fun:__realpath_chk=uninstrumented fun:__recv=uninstrumented fun:__recv_chk=uninstrumented fun:__recvfrom_chk=uninstrumented fun:__register_atfork=uninstrumented fun:__register_frame=uninstrumented fun:__register_frame_info=uninstrumented fun:__register_frame_info_bases=uninstrumented fun:__register_frame_info_table=uninstrumented fun:__register_frame_info_table_bases=uninstrumented fun:__register_frame_table=uninstrumented fun:__remainder_finite=uninstrumented fun:__remainderf128_finite=uninstrumented fun:__remainderf_finite=uninstrumented fun:__remainderl_finite=uninstrumented fun:__res_close=uninstrumented fun:__res_context_hostalias=uninstrumented fun:__res_context_mkquery=uninstrumented fun:__res_context_query=uninstrumented fun:__res_context_search=uninstrumented fun:__res_context_send=uninstrumented fun:__res_dnok=uninstrumented fun:__res_get_nsaddr=uninstrumented fun:__res_hnok=uninstrumented fun:__res_hostalias=uninstrumented fun:__res_iclose=uninstrumented fun:__res_init=uninstrumented fun:__res_isourserver=uninstrumented fun:__res_mailok=uninstrumented fun:__res_mkquery=uninstrumented fun:__res_nameinquery=uninstrumented fun:__res_nclose=uninstrumented fun:__res_ninit=uninstrumented fun:__res_nmkquery=uninstrumented fun:__res_nopt=uninstrumented fun:__res_nquery=uninstrumented fun:__res_nquerydomain=uninstrumented fun:__res_nsearch=uninstrumented fun:__res_nsend=uninstrumented fun:__res_ownok=uninstrumented fun:__res_queriesmatch=uninstrumented fun:__res_query=uninstrumented fun:__res_querydomain=uninstrumented fun:__res_randomid=uninstrumented fun:__res_search=uninstrumented fun:__res_send=uninstrumented fun:__res_state=uninstrumented fun:__resolv_context_get=uninstrumented fun:__resolv_context_get_override=uninstrumented fun:__resolv_context_get_preinit=uninstrumented fun:__resolv_context_put=uninstrumented fun:__rpc_thread_createerr=uninstrumented fun:__rpc_thread_svc_fdset=uninstrumented fun:__rpc_thread_svc_max_pollfd=uninstrumented fun:__rpc_thread_svc_pollfd=uninstrumented fun:__rtld_version_placeholder=uninstrumented fun:__sbrk=uninstrumented fun:__scalb_finite=uninstrumented fun:__scalbf_finite=uninstrumented fun:__scalbl_finite=uninstrumented fun:__sched_cpualloc=uninstrumented fun:__sched_cpucount=uninstrumented fun:__sched_cpufree=uninstrumented fun:__sched_get_priority_max=uninstrumented fun:__sched_get_priority_min=uninstrumented fun:__sched_getparam=uninstrumented fun:__sched_getscheduler=uninstrumented fun:__sched_setscheduler=uninstrumented fun:__sched_yield=uninstrumented fun:__secure_getenv=uninstrumented fun:__select=uninstrumented fun:__send=uninstrumented fun:__sendmmsg=uninstrumented fun:__setmntent=uninstrumented fun:__setpgid=uninstrumented fun:__sfp_handle_exceptions=uninstrumented fun:__shm_get_name=uninstrumented fun:__sigaction=uninstrumented fun:__sigaddset=uninstrumented fun:__sigdelset=uninstrumented fun:__sigismember=uninstrumented fun:__signbit=uninstrumented fun:__signbitf=uninstrumented fun:__signbitf128=uninstrumented fun:__signbitl=uninstrumented fun:__sigpause=uninstrumented fun:__sigsetjmp=uninstrumented fun:__sigsuspend=uninstrumented fun:__sigtimedwait=uninstrumented fun:__sinh_finite=uninstrumented fun:__sinhf128_finite=uninstrumented fun:__sinhf_finite=uninstrumented fun:__sinhl_finite=uninstrumented fun:__snprintf=uninstrumented fun:__snprintf_chk=uninstrumented fun:__socket=uninstrumented fun:__splitstack_block_signals=uninstrumented fun:__splitstack_block_signals_context=uninstrumented fun:__splitstack_find=uninstrumented fun:__splitstack_find_context=uninstrumented fun:__splitstack_getcontext=uninstrumented fun:__splitstack_makecontext=uninstrumented fun:__splitstack_releasecontext=uninstrumented fun:__splitstack_resetcontext=uninstrumented fun:__splitstack_setcontext=uninstrumented fun:__sprintf_chk=uninstrumented fun:__sqrt_finite=uninstrumented fun:__sqrtf128_finite=uninstrumented fun:__sqrtf_finite=uninstrumented fun:__sqrtl_finite=uninstrumented fun:__sse_resms64_12=uninstrumented fun:__sse_resms64_13=uninstrumented fun:__sse_resms64_14=uninstrumented fun:__sse_resms64_15=uninstrumented fun:__sse_resms64_16=uninstrumented fun:__sse_resms64_17=uninstrumented fun:__sse_resms64_18=uninstrumented fun:__sse_resms64f_12=uninstrumented fun:__sse_resms64f_13=uninstrumented fun:__sse_resms64f_14=uninstrumented fun:__sse_resms64f_15=uninstrumented fun:__sse_resms64f_16=uninstrumented fun:__sse_resms64f_17=uninstrumented fun:__sse_resms64fx_12=uninstrumented fun:__sse_resms64fx_13=uninstrumented fun:__sse_resms64fx_14=uninstrumented fun:__sse_resms64fx_15=uninstrumented fun:__sse_resms64fx_16=uninstrumented fun:__sse_resms64fx_17=uninstrumented fun:__sse_resms64x_12=uninstrumented fun:__sse_resms64x_13=uninstrumented fun:__sse_resms64x_14=uninstrumented fun:__sse_resms64x_15=uninstrumented fun:__sse_resms64x_16=uninstrumented fun:__sse_resms64x_17=uninstrumented fun:__sse_resms64x_18=uninstrumented fun:__sse_savms64_12=uninstrumented fun:__sse_savms64_13=uninstrumented fun:__sse_savms64_14=uninstrumented fun:__sse_savms64_15=uninstrumented fun:__sse_savms64_16=uninstrumented fun:__sse_savms64_17=uninstrumented fun:__sse_savms64_18=uninstrumented fun:__sse_savms64f_12=uninstrumented fun:__sse_savms64f_13=uninstrumented fun:__sse_savms64f_14=uninstrumented fun:__sse_savms64f_15=uninstrumented fun:__sse_savms64f_16=uninstrumented fun:__sse_savms64f_17=uninstrumented fun:__stack_chk_fail=uninstrumented fun:__stack_chk_fail_local=uninstrumented fun:__stack_split_initialize=uninstrumented fun:__statfs=uninstrumented fun:__stpcpy=uninstrumented fun:__stpcpy_chk=uninstrumented fun:__stpcpy_small=uninstrumented fun:__stpncpy=uninstrumented fun:__stpncpy_chk=uninstrumented fun:__strcasecmp=uninstrumented fun:__strcasecmp_l=uninstrumented fun:__strcasestr=uninstrumented fun:__strcat_chk=uninstrumented fun:__strcoll_l=uninstrumented fun:__strcpy_chk=uninstrumented fun:__strcpy_small=uninstrumented fun:__strcspn_c1=uninstrumented fun:__strcspn_c2=uninstrumented fun:__strcspn_c3=uninstrumented fun:__strdup=uninstrumented fun:__strerror_r=uninstrumented fun:__strfmon_l=uninstrumented fun:__strftime_l=uninstrumented fun:__strncasecmp_l=uninstrumented fun:__strncat_chk=uninstrumented fun:__strncpy_chk=uninstrumented fun:__strndup=uninstrumented fun:__strpbrk_c2=uninstrumented fun:__strpbrk_c3=uninstrumented fun:__strsep_1c=uninstrumented fun:__strsep_2c=uninstrumented fun:__strsep_3c=uninstrumented fun:__strsep_g=uninstrumented fun:__strspn_c1=uninstrumented fun:__strspn_c2=uninstrumented fun:__strspn_c3=uninstrumented fun:__strtod_internal=uninstrumented fun:__strtod_l=uninstrumented fun:__strtod_nan=uninstrumented fun:__strtof128_internal=uninstrumented fun:__strtof128_nan=uninstrumented fun:__strtof_internal=uninstrumented fun:__strtof_l=uninstrumented fun:__strtof_nan=uninstrumented fun:__strtok_r=uninstrumented fun:__strtok_r_1c=uninstrumented fun:__strtol_internal=uninstrumented fun:__strtol_l=uninstrumented fun:__strtold_internal=uninstrumented fun:__strtold_l=uninstrumented fun:__strtold_nan=uninstrumented fun:__strtoll_internal=uninstrumented fun:__strtoll_l=uninstrumented fun:__strtoul_internal=uninstrumented fun:__strtoul_l=uninstrumented fun:__strtoull_internal=uninstrumented fun:__strtoull_l=uninstrumented fun:__strverscmp=uninstrumented fun:__strxfrm_l=uninstrumented fun:__subtf3=uninstrumented fun:__subvdi3=uninstrumented fun:__subvsi3=uninstrumented fun:__subvti3=uninstrumented fun:__swprintf_chk=uninstrumented fun:__sym_ntop=uninstrumented fun:__sym_ntos=uninstrumented fun:__sym_ston=uninstrumented fun:__sysconf=uninstrumented fun:__sysctl=uninstrumented fun:__syslog_chk=uninstrumented fun:__sysv_signal=uninstrumented fun:__tdelete=uninstrumented fun:__tfind=uninstrumented fun:__tls_get_addr=uninstrumented fun:__toascii_l=uninstrumented fun:__tolower_l=uninstrumented fun:__toupper_l=uninstrumented fun:__towctrans=uninstrumented fun:__towctrans_l=uninstrumented fun:__towlower_l=uninstrumented fun:__towupper_l=uninstrumented fun:__truncdfhf2=uninstrumented fun:__truncdfsf2=uninstrumented fun:__truncsfhf2=uninstrumented fun:__trunctfdf2=uninstrumented fun:__trunctfhf2=uninstrumented fun:__trunctfsf2=uninstrumented fun:__trunctfxf2=uninstrumented fun:__truncxfhf2=uninstrumented fun:__tsearch=uninstrumented fun:__ttyname_r_chk=uninstrumented fun:__tunable_get_val=uninstrumented fun:__twalk=uninstrumented fun:__twalk_r=uninstrumented fun:__ucmpti2=uninstrumented fun:__udiv_w_sdiv=uninstrumented fun:__udivmodti4=uninstrumented fun:__udivti3=uninstrumented fun:__uflow=uninstrumented fun:__umodti3=uninstrumented fun:__underflow=uninstrumented fun:__unordtf2=uninstrumented fun:__uselocale=uninstrumented fun:__vasprintf_chk=uninstrumented fun:__vdprintf_chk=uninstrumented fun:__vfork=uninstrumented fun:__vfprintf_chk=uninstrumented fun:__vfscanf=uninstrumented fun:__vfwprintf_chk=uninstrumented fun:__vprintf_chk=uninstrumented fun:__vsnprintf=uninstrumented fun:__vsnprintf_chk=uninstrumented fun:__vsprintf_chk=uninstrumented fun:__vsscanf=uninstrumented fun:__vswprintf_chk=uninstrumented fun:__vsyslog_chk=uninstrumented fun:__vwprintf_chk=uninstrumented fun:__wait=uninstrumented fun:__waitpid=uninstrumented fun:__wcpcpy_chk=uninstrumented fun:__wcpncpy_chk=uninstrumented fun:__wcrtomb_chk=uninstrumented fun:__wcscasecmp_l=uninstrumented fun:__wcscat_chk=uninstrumented fun:__wcscoll_l=uninstrumented fun:__wcscpy_chk=uninstrumented fun:__wcsftime_l=uninstrumented fun:__wcsncasecmp_l=uninstrumented fun:__wcsncat_chk=uninstrumented fun:__wcsncpy_chk=uninstrumented fun:__wcsnrtombs_chk=uninstrumented fun:__wcsrtombs_chk=uninstrumented fun:__wcstod_internal=uninstrumented fun:__wcstod_l=uninstrumented fun:__wcstof128_internal=uninstrumented fun:__wcstof_internal=uninstrumented fun:__wcstof_l=uninstrumented fun:__wcstol_internal=uninstrumented fun:__wcstol_l=uninstrumented fun:__wcstold_internal=uninstrumented fun:__wcstold_l=uninstrumented fun:__wcstoll_internal=uninstrumented fun:__wcstoll_l=uninstrumented fun:__wcstombs_chk=uninstrumented fun:__wcstoul_internal=uninstrumented fun:__wcstoul_l=uninstrumented fun:__wcstoull_internal=uninstrumented fun:__wcstoull_l=uninstrumented fun:__wcsxfrm_l=uninstrumented fun:__wctomb_chk=uninstrumented fun:__wctrans_l=uninstrumented fun:__wctype_l=uninstrumented fun:__wmemcpy_chk=uninstrumented fun:__wmemmove_chk=uninstrumented fun:__wmempcpy_chk=uninstrumented fun:__wmemset_chk=uninstrumented fun:__woverflow=uninstrumented fun:__wprintf_chk=uninstrumented fun:__wrap_pthread_create=uninstrumented fun:__write=uninstrumented fun:__write_nocancel=uninstrumented fun:__wuflow=uninstrumented fun:__wunderflow=uninstrumented fun:__x86_get_cpuid_feature_leaf=uninstrumented fun:__xmknod=uninstrumented fun:__xmknodat=uninstrumented fun:__xpg_basename=uninstrumented fun:__xpg_sigpause=uninstrumented fun:__xpg_strerror_r=uninstrumented fun:__xstat=uninstrumented fun:__xstat64=uninstrumented fun:__y0_finite=uninstrumented fun:__y0f128_finite=uninstrumented fun:__y0f_finite=uninstrumented fun:__y0l_finite=uninstrumented fun:__y1_finite=uninstrumented fun:__y1f128_finite=uninstrumented fun:__y1f_finite=uninstrumented fun:__y1l_finite=uninstrumented fun:__yn_finite=uninstrumented fun:__ynf128_finite=uninstrumented fun:__ynf_finite=uninstrumented fun:__ynl_finite=uninstrumented fun:__yp_check=uninstrumented fun:_authenticate=uninstrumented fun:_dl_allocate_tls=uninstrumented fun:_dl_allocate_tls_init=uninstrumented fun:_dl_audit_preinit=uninstrumented fun:_dl_audit_symbind_alt=uninstrumented fun:_dl_catch_error=uninstrumented fun:_dl_catch_exception=uninstrumented fun:_dl_deallocate_tls=uninstrumented fun:_dl_debug_state=uninstrumented fun:_dl_exception_create=uninstrumented fun:_dl_exception_create_format=uninstrumented fun:_dl_exception_free=uninstrumented fun:_dl_fatal_printf=uninstrumented fun:_dl_find_dso_for_object=uninstrumented fun:_dl_find_object=uninstrumented fun:_dl_get_tls_static_info=uninstrumented fun:_dl_mcount=uninstrumented fun:_dl_mcount_wrapper=uninstrumented fun:_dl_mcount_wrapper_check=uninstrumented fun:_dl_rtld_di_serinfo=uninstrumented fun:_dl_signal_error=uninstrumented fun:_dl_signal_exception=uninstrumented fun:_dl_x86_get_cpu_features=uninstrumented fun:_exit=uninstrumented fun:_flushlbf=uninstrumented fun:_gethtbyaddr=uninstrumented fun:_gethtbyname=uninstrumented fun:_gethtbyname2=uninstrumented fun:_gethtent=uninstrumented fun:_getlong=uninstrumented fun:_getshort=uninstrumented fun:_longjmp=uninstrumented fun:_mcleanup=uninstrumented fun:_mcount=uninstrumented fun:_nss_dns_getcanonname_r=uninstrumented fun:_nss_dns_gethostbyaddr2_r=uninstrumented fun:_nss_dns_gethostbyaddr_r=uninstrumented fun:_nss_dns_gethostbyname2_r=uninstrumented fun:_nss_dns_gethostbyname3_r=uninstrumented fun:_nss_dns_gethostbyname4_r=uninstrumented fun:_nss_dns_gethostbyname_r=uninstrumented fun:_nss_dns_getnetbyaddr_r=uninstrumented fun:_nss_dns_getnetbyname_r=uninstrumented fun:_nss_files_endaliasent=uninstrumented fun:_nss_files_endetherent=uninstrumented fun:_nss_files_endgrent=uninstrumented fun:_nss_files_endhostent=uninstrumented fun:_nss_files_endnetent=uninstrumented fun:_nss_files_endnetgrent=uninstrumented fun:_nss_files_endprotoent=uninstrumented fun:_nss_files_endpwent=uninstrumented fun:_nss_files_endrpcent=uninstrumented fun:_nss_files_endservent=uninstrumented fun:_nss_files_endsgent=uninstrumented fun:_nss_files_endspent=uninstrumented fun:_nss_files_getaliasbyname_r=uninstrumented fun:_nss_files_getaliasent_r=uninstrumented fun:_nss_files_getetherent_r=uninstrumented fun:_nss_files_getgrent_r=uninstrumented fun:_nss_files_getgrgid_r=uninstrumented fun:_nss_files_getgrnam_r=uninstrumented fun:_nss_files_gethostbyaddr_r=uninstrumented fun:_nss_files_gethostbyname2_r=uninstrumented fun:_nss_files_gethostbyname3_r=uninstrumented fun:_nss_files_gethostbyname4_r=uninstrumented fun:_nss_files_gethostbyname_r=uninstrumented fun:_nss_files_gethostent_r=uninstrumented fun:_nss_files_gethostton_r=uninstrumented fun:_nss_files_getnetbyaddr_r=uninstrumented fun:_nss_files_getnetbyname_r=uninstrumented fun:_nss_files_getnetent_r=uninstrumented fun:_nss_files_getnetgrent_r=uninstrumented fun:_nss_files_getntohost_r=uninstrumented fun:_nss_files_getprotobyname_r=uninstrumented fun:_nss_files_getprotobynumber_r=uninstrumented fun:_nss_files_getprotoent_r=uninstrumented fun:_nss_files_getpwent_r=uninstrumented fun:_nss_files_getpwnam_r=uninstrumented fun:_nss_files_getpwuid_r=uninstrumented fun:_nss_files_getrpcbyname_r=uninstrumented fun:_nss_files_getrpcbynumber_r=uninstrumented fun:_nss_files_getrpcent_r=uninstrumented fun:_nss_files_getservbyname_r=uninstrumented fun:_nss_files_getservbyport_r=uninstrumented fun:_nss_files_getservent_r=uninstrumented fun:_nss_files_getsgent_r=uninstrumented fun:_nss_files_getsgnam_r=uninstrumented fun:_nss_files_getspent_r=uninstrumented fun:_nss_files_getspnam_r=uninstrumented fun:_nss_files_init=uninstrumented fun:_nss_files_initgroups_dyn=uninstrumented fun:_nss_files_parse_etherent=uninstrumented fun:_nss_files_parse_grent=uninstrumented fun:_nss_files_parse_netent=uninstrumented fun:_nss_files_parse_protoent=uninstrumented fun:_nss_files_parse_pwent=uninstrumented fun:_nss_files_parse_rpcent=uninstrumented fun:_nss_files_parse_servent=uninstrumented fun:_nss_files_parse_sgent=uninstrumented fun:_nss_files_parse_spent=uninstrumented fun:_nss_files_setaliasent=uninstrumented fun:_nss_files_setetherent=uninstrumented fun:_nss_files_setgrent=uninstrumented fun:_nss_files_sethostent=uninstrumented fun:_nss_files_setnetent=uninstrumented fun:_nss_files_setnetgrent=uninstrumented fun:_nss_files_setprotoent=uninstrumented fun:_nss_files_setpwent=uninstrumented fun:_nss_files_setrpcent=uninstrumented fun:_nss_files_setservent=uninstrumented fun:_nss_files_setsgent=uninstrumented fun:_nss_files_setspent=uninstrumented fun:_nss_netgroup_parseline=uninstrumented fun:_obstack_allocated_p=uninstrumented fun:_obstack_begin=uninstrumented fun:_obstack_begin_1=uninstrumented fun:_obstack_free=uninstrumented fun:_obstack_memory_used=uninstrumented fun:_obstack_newchunk=uninstrumented fun:_pthread_cleanup_pop=uninstrumented fun:_pthread_cleanup_pop_restore=uninstrumented fun:_pthread_cleanup_push=uninstrumented fun:_pthread_cleanup_push_defer=uninstrumented fun:_rpc_dtablesize=uninstrumented fun:_seterr_reply=uninstrumented fun:_sethtent=uninstrumented fun:_setjmp=uninstrumented fun:_tolower=uninstrumented fun:_toupper=uninstrumented fun:_xdr_ib_request=uninstrumented fun:_xdr_nis_result=uninstrumented fun:a64l=uninstrumented fun:abort=uninstrumented fun:abs=uninstrumented fun:accept=uninstrumented fun:accept4=uninstrumented fun:access=uninstrumented fun:acct=uninstrumented fun:acos=uninstrumented fun:acosf=uninstrumented fun:acosf128=uninstrumented fun:acosf32=uninstrumented fun:acosf32x=uninstrumented fun:acosf64=uninstrumented fun:acosf64x=uninstrumented fun:acosh=uninstrumented fun:acoshf=uninstrumented fun:acoshf128=uninstrumented fun:acoshf32=uninstrumented fun:acoshf32x=uninstrumented fun:acoshf64=uninstrumented fun:acoshf64x=uninstrumented fun:acoshl=uninstrumented fun:acosl=uninstrumented fun:addmntent=uninstrumented fun:addseverity=uninstrumented fun:adjtime=uninstrumented fun:adjtimex=uninstrumented fun:advance=uninstrumented fun:aio_cancel=uninstrumented fun:aio_cancel64=uninstrumented fun:aio_error=uninstrumented fun:aio_error64=uninstrumented fun:aio_fsync=uninstrumented fun:aio_fsync64=uninstrumented fun:aio_init=uninstrumented fun:aio_read=uninstrumented fun:aio_read64=uninstrumented fun:aio_return=uninstrumented fun:aio_return64=uninstrumented fun:aio_suspend=uninstrumented fun:aio_suspend64=uninstrumented fun:aio_write=uninstrumented fun:aio_write64=uninstrumented fun:alarm=uninstrumented fun:aligned_alloc=uninstrumented fun:alphasort=uninstrumented fun:alphasort64=uninstrumented fun:arch_prctl=uninstrumented fun:argp_error=uninstrumented fun:argp_failure=uninstrumented fun:argp_help=uninstrumented fun:argp_parse=uninstrumented fun:argp_state_help=uninstrumented fun:argp_usage=uninstrumented fun:argz_add=uninstrumented fun:argz_add_sep=uninstrumented fun:argz_append=uninstrumented fun:argz_count=uninstrumented fun:argz_create=uninstrumented fun:argz_create_sep=uninstrumented fun:argz_delete=uninstrumented fun:argz_extract=uninstrumented fun:argz_insert=uninstrumented fun:argz_next=uninstrumented fun:argz_replace=uninstrumented fun:argz_stringify=uninstrumented fun:asctime=uninstrumented fun:asctime_r=uninstrumented fun:asin=uninstrumented fun:asinf=uninstrumented fun:asinf128=uninstrumented fun:asinf32=uninstrumented fun:asinf32x=uninstrumented fun:asinf64=uninstrumented fun:asinf64x=uninstrumented fun:asinh=uninstrumented fun:asinhf=uninstrumented fun:asinhf128=uninstrumented fun:asinhf32=uninstrumented fun:asinhf32x=uninstrumented fun:asinhf64=uninstrumented fun:asinhf64x=uninstrumented fun:asinhl=uninstrumented fun:asinl=uninstrumented fun:asprintf=uninstrumented fun:at_quick_exit=uninstrumented fun:atan=uninstrumented fun:atan2=uninstrumented fun:atan2f=uninstrumented fun:atan2f128=uninstrumented fun:atan2f32=uninstrumented fun:atan2f32x=uninstrumented fun:atan2f64=uninstrumented fun:atan2f64x=uninstrumented fun:atan2l=uninstrumented fun:atanf=uninstrumented fun:atanf128=uninstrumented fun:atanf32=uninstrumented fun:atanf32x=uninstrumented fun:atanf64=uninstrumented fun:atanf64x=uninstrumented fun:atanh=uninstrumented fun:atanhf=uninstrumented fun:atanhf128=uninstrumented fun:atanhf32=uninstrumented fun:atanhf32x=uninstrumented fun:atanhf64=uninstrumented fun:atanhf64x=uninstrumented fun:atanhl=uninstrumented fun:atanl=uninstrumented fun:atexit=uninstrumented fun:atof=uninstrumented fun:atoi=uninstrumented fun:atol=uninstrumented fun:atoll=uninstrumented fun:authdes_create=uninstrumented fun:authdes_getucred=uninstrumented fun:authdes_pk_create=uninstrumented fun:authnone_create=uninstrumented fun:authunix_create=uninstrumented fun:authunix_create_default=uninstrumented fun:backtrace=uninstrumented fun:backtrace_symbols=uninstrumented fun:backtrace_symbols_fd=uninstrumented fun:basename=uninstrumented fun:bcmp=uninstrumented fun:bcopy=uninstrumented fun:bdflush=uninstrumented fun:bind=uninstrumented fun:bind_textdomain_codeset=uninstrumented fun:bindresvport=uninstrumented fun:bindtextdomain=uninstrumented fun:brk=uninstrumented fun:bsd_signal=uninstrumented fun:bsearch=uninstrumented fun:btowc=uninstrumented fun:bzero=uninstrumented fun:c16rtomb=uninstrumented fun:c32rtomb=uninstrumented fun:cabs=uninstrumented fun:cabsf=uninstrumented fun:cabsf128=uninstrumented fun:cabsf32=uninstrumented fun:cabsf32x=uninstrumented fun:cabsf64=uninstrumented fun:cabsf64x=uninstrumented fun:cabsl=uninstrumented fun:cacos=uninstrumented fun:cacosf=uninstrumented fun:cacosf128=uninstrumented fun:cacosf32=uninstrumented fun:cacosf32x=uninstrumented fun:cacosf64=uninstrumented fun:cacosf64x=uninstrumented fun:cacosh=uninstrumented fun:cacoshf=uninstrumented fun:cacoshf128=uninstrumented fun:cacoshf32=uninstrumented fun:cacoshf32x=uninstrumented fun:cacoshf64=uninstrumented fun:cacoshf64x=uninstrumented fun:cacoshl=uninstrumented fun:cacosl=uninstrumented fun:call_once=uninstrumented fun:calloc=uninstrumented fun:callrpc=uninstrumented fun:canonicalize=uninstrumented fun:canonicalize_file_name=uninstrumented fun:canonicalizef=uninstrumented fun:canonicalizef128=uninstrumented fun:canonicalizef32=uninstrumented fun:canonicalizef32x=uninstrumented fun:canonicalizef64=uninstrumented fun:canonicalizef64x=uninstrumented fun:canonicalizel=uninstrumented fun:capget=uninstrumented fun:capset=uninstrumented fun:carg=uninstrumented fun:cargf=uninstrumented fun:cargf128=uninstrumented fun:cargf32=uninstrumented fun:cargf32x=uninstrumented fun:cargf64=uninstrumented fun:cargf64x=uninstrumented fun:cargl=uninstrumented fun:casin=uninstrumented fun:casinf=uninstrumented fun:casinf128=uninstrumented fun:casinf32=uninstrumented fun:casinf32x=uninstrumented fun:casinf64=uninstrumented fun:casinf64x=uninstrumented fun:casinh=uninstrumented fun:casinhf=uninstrumented fun:casinhf128=uninstrumented fun:casinhf32=uninstrumented fun:casinhf32x=uninstrumented fun:casinhf64=uninstrumented fun:casinhf64x=uninstrumented fun:casinhl=uninstrumented fun:casinl=uninstrumented fun:catan=uninstrumented fun:catanf=uninstrumented fun:catanf128=uninstrumented fun:catanf32=uninstrumented fun:catanf32x=uninstrumented fun:catanf64=uninstrumented fun:catanf64x=uninstrumented fun:catanh=uninstrumented fun:catanhf=uninstrumented fun:catanhf128=uninstrumented fun:catanhf32=uninstrumented fun:catanhf32x=uninstrumented fun:catanhf64=uninstrumented fun:catanhf64x=uninstrumented fun:catanhl=uninstrumented fun:catanl=uninstrumented fun:catclose=uninstrumented fun:catgets=uninstrumented fun:catopen=uninstrumented fun:cbc_crypt=uninstrumented fun:cbrt=uninstrumented fun:cbrtf=uninstrumented fun:cbrtf128=uninstrumented fun:cbrtf32=uninstrumented fun:cbrtf32x=uninstrumented fun:cbrtf64=uninstrumented fun:cbrtf64x=uninstrumented fun:cbrtl=uninstrumented fun:ccos=uninstrumented fun:ccosf=uninstrumented fun:ccosf128=uninstrumented fun:ccosf32=uninstrumented fun:ccosf32x=uninstrumented fun:ccosf64=uninstrumented fun:ccosf64x=uninstrumented fun:ccosh=uninstrumented fun:ccoshf=uninstrumented fun:ccoshf128=uninstrumented fun:ccoshf32=uninstrumented fun:ccoshf32x=uninstrumented fun:ccoshf64=uninstrumented fun:ccoshf64x=uninstrumented fun:ccoshl=uninstrumented fun:ccosl=uninstrumented fun:ceil=uninstrumented fun:ceilf=uninstrumented fun:ceilf128=uninstrumented fun:ceilf32=uninstrumented fun:ceilf32x=uninstrumented fun:ceilf64=uninstrumented fun:ceilf64x=uninstrumented fun:ceill=uninstrumented fun:cexp=uninstrumented fun:cexpf=uninstrumented fun:cexpf128=uninstrumented fun:cexpf32=uninstrumented fun:cexpf32x=uninstrumented fun:cexpf64=uninstrumented fun:cexpf64x=uninstrumented fun:cexpl=uninstrumented fun:cfgetispeed=uninstrumented fun:cfgetospeed=uninstrumented fun:cfmakeraw=uninstrumented fun:cfree=uninstrumented fun:cfsetispeed=uninstrumented fun:cfsetospeed=uninstrumented fun:cfsetspeed=uninstrumented fun:chdir=uninstrumented fun:chflags=uninstrumented fun:chmod=uninstrumented fun:chown=uninstrumented fun:chroot=uninstrumented fun:cimag=uninstrumented fun:cimagf=uninstrumented fun:cimagf128=uninstrumented fun:cimagf32=uninstrumented fun:cimagf32x=uninstrumented fun:cimagf64=uninstrumented fun:cimagf64x=uninstrumented fun:cimagl=uninstrumented fun:clearenv=uninstrumented fun:clearerr=uninstrumented fun:clearerr_unlocked=uninstrumented fun:clnt_broadcast=uninstrumented fun:clnt_create=uninstrumented fun:clnt_pcreateerror=uninstrumented fun:clnt_perrno=uninstrumented fun:clnt_perror=uninstrumented fun:clnt_spcreateerror=uninstrumented fun:clnt_sperrno=uninstrumented fun:clnt_sperror=uninstrumented fun:clntraw_create=uninstrumented fun:clnttcp_create=uninstrumented fun:clntudp_bufcreate=uninstrumented fun:clntudp_create=uninstrumented fun:clntunix_create=uninstrumented fun:clock=uninstrumented fun:clock_adjtime=uninstrumented fun:clock_getcpuclockid=uninstrumented fun:clock_getres=uninstrumented fun:clock_gettime=uninstrumented fun:clock_nanosleep=uninstrumented fun:clock_settime=uninstrumented fun:clog=uninstrumented fun:clog10=uninstrumented fun:clog10f=uninstrumented fun:clog10f128=uninstrumented fun:clog10f32=uninstrumented fun:clog10f32x=uninstrumented fun:clog10f64=uninstrumented fun:clog10f64x=uninstrumented fun:clog10l=uninstrumented fun:clogf=uninstrumented fun:clogf128=uninstrumented fun:clogf32=uninstrumented fun:clogf32x=uninstrumented fun:clogf64=uninstrumented fun:clogf64x=uninstrumented fun:clogl=uninstrumented fun:clone=uninstrumented fun:close=uninstrumented fun:close_range=uninstrumented fun:closedir=uninstrumented fun:closefrom=uninstrumented fun:closelog=uninstrumented fun:cnd_broadcast=uninstrumented fun:cnd_destroy=uninstrumented fun:cnd_init=uninstrumented fun:cnd_signal=uninstrumented fun:cnd_timedwait=uninstrumented fun:cnd_wait=uninstrumented fun:confstr=uninstrumented fun:conj=uninstrumented fun:conjf=uninstrumented fun:conjf128=uninstrumented fun:conjf32=uninstrumented fun:conjf32x=uninstrumented fun:conjf64=uninstrumented fun:conjf64x=uninstrumented fun:conjl=uninstrumented fun:connect=uninstrumented fun:copy_file_range=uninstrumented fun:copysign=uninstrumented fun:copysignf=uninstrumented fun:copysignf128=uninstrumented fun:copysignf32=uninstrumented fun:copysignf32x=uninstrumented fun:copysignf64=uninstrumented fun:copysignf64x=uninstrumented fun:copysignl=uninstrumented fun:cos=uninstrumented fun:cosf=uninstrumented fun:cosf128=uninstrumented fun:cosf32=uninstrumented fun:cosf32x=uninstrumented fun:cosf64=uninstrumented fun:cosf64x=uninstrumented fun:cosh=uninstrumented fun:coshf=uninstrumented fun:coshf128=uninstrumented fun:coshf32=uninstrumented fun:coshf32x=uninstrumented fun:coshf64=uninstrumented fun:coshf64x=uninstrumented fun:coshl=uninstrumented fun:cosl=uninstrumented fun:cpow=uninstrumented fun:cpowf=uninstrumented fun:cpowf128=uninstrumented fun:cpowf32=uninstrumented fun:cpowf32x=uninstrumented fun:cpowf64=uninstrumented fun:cpowf64x=uninstrumented fun:cpowl=uninstrumented fun:cproj=uninstrumented fun:cprojf=uninstrumented fun:cprojf128=uninstrumented fun:cprojf32=uninstrumented fun:cprojf32x=uninstrumented fun:cprojf64=uninstrumented fun:cprojf64x=uninstrumented fun:cprojl=uninstrumented fun:creal=uninstrumented fun:crealf=uninstrumented fun:crealf128=uninstrumented fun:crealf32=uninstrumented fun:crealf32x=uninstrumented fun:crealf64=uninstrumented fun:crealf64x=uninstrumented fun:creall=uninstrumented fun:creat=uninstrumented fun:creat64=uninstrumented fun:create_module=uninstrumented fun:crypt=uninstrumented fun:crypt_checksalt=uninstrumented fun:crypt_gensalt=uninstrumented fun:crypt_gensalt_r=uninstrumented fun:crypt_gensalt_ra=uninstrumented fun:crypt_gensalt_rn=uninstrumented fun:crypt_preferred_method=uninstrumented fun:crypt_r=uninstrumented fun:crypt_ra=uninstrumented fun:crypt_rn=uninstrumented fun:csin=uninstrumented fun:csinf=uninstrumented fun:csinf128=uninstrumented fun:csinf32=uninstrumented fun:csinf32x=uninstrumented fun:csinf64=uninstrumented fun:csinf64x=uninstrumented fun:csinh=uninstrumented fun:csinhf=uninstrumented fun:csinhf128=uninstrumented fun:csinhf32=uninstrumented fun:csinhf32x=uninstrumented fun:csinhf64=uninstrumented fun:csinhf64x=uninstrumented fun:csinhl=uninstrumented fun:csinl=uninstrumented fun:csqrt=uninstrumented fun:csqrtf=uninstrumented fun:csqrtf128=uninstrumented fun:csqrtf32=uninstrumented fun:csqrtf32x=uninstrumented fun:csqrtf64=uninstrumented fun:csqrtf64x=uninstrumented fun:csqrtl=uninstrumented fun:ctan=uninstrumented fun:ctanf=uninstrumented fun:ctanf128=uninstrumented fun:ctanf32=uninstrumented fun:ctanf32x=uninstrumented fun:ctanf64=uninstrumented fun:ctanf64x=uninstrumented fun:ctanh=uninstrumented fun:ctanhf=uninstrumented fun:ctanhf128=uninstrumented fun:ctanhf32=uninstrumented fun:ctanhf32x=uninstrumented fun:ctanhf64=uninstrumented fun:ctanhf64x=uninstrumented fun:ctanhl=uninstrumented fun:ctanl=uninstrumented fun:ctermid=uninstrumented fun:ctime=uninstrumented fun:ctime_r=uninstrumented fun:cuserid=uninstrumented fun:daddl=uninstrumented fun:daemon=uninstrumented fun:dcgettext=uninstrumented fun:dcngettext=uninstrumented fun:ddivl=uninstrumented fun:delete_module=uninstrumented fun:des_setparity=uninstrumented fun:dfmal=uninstrumented fun:dgettext=uninstrumented fun:difftime=uninstrumented fun:dirfd=uninstrumented fun:dirname=uninstrumented fun:div=uninstrumented fun:dl_iterate_phdr=uninstrumented fun:dladdr=uninstrumented fun:dladdr1=uninstrumented fun:dlclose=uninstrumented fun:dlerror=uninstrumented fun:dlinfo=uninstrumented fun:dlmopen=uninstrumented fun:dlopen=uninstrumented fun:dlsym=uninstrumented fun:dlvsym=uninstrumented fun:dmull=uninstrumented fun:dn_comp=uninstrumented fun:dn_expand=uninstrumented fun:dn_skipname=uninstrumented fun:dngettext=uninstrumented fun:dprintf=uninstrumented fun:drand48=uninstrumented fun:drand48_r=uninstrumented fun:drem=uninstrumented fun:dremf=uninstrumented fun:dreml=uninstrumented fun:dsqrtl=uninstrumented fun:dsubl=uninstrumented fun:dup=uninstrumented fun:dup2=uninstrumented fun:dup3=uninstrumented fun:duplocale=uninstrumented fun:dysize=uninstrumented fun:eaccess=uninstrumented fun:ecb_crypt=uninstrumented fun:ecvt=uninstrumented fun:ecvt_r=uninstrumented fun:encrypt=uninstrumented fun:encrypt_r=uninstrumented fun:endaliasent=uninstrumented fun:endfsent=uninstrumented fun:endgrent=uninstrumented fun:endhostent=uninstrumented fun:endmntent=uninstrumented fun:endnetent=uninstrumented fun:endnetgrent=uninstrumented fun:endprotoent=uninstrumented fun:endpwent=uninstrumented fun:endrpcent=uninstrumented fun:endservent=uninstrumented fun:endsgent=uninstrumented fun:endspent=uninstrumented fun:endttyent=uninstrumented fun:endusershell=uninstrumented fun:endutent=uninstrumented fun:endutxent=uninstrumented fun:envz_add=uninstrumented fun:envz_entry=uninstrumented fun:envz_get=uninstrumented fun:envz_merge=uninstrumented fun:envz_remove=uninstrumented fun:envz_strip=uninstrumented fun:epoll_create=uninstrumented fun:epoll_create1=uninstrumented fun:epoll_ctl=uninstrumented fun:epoll_pwait=uninstrumented fun:epoll_pwait2=uninstrumented fun:epoll_wait=uninstrumented fun:erand48=uninstrumented fun:erand48_r=uninstrumented fun:erf=uninstrumented fun:erfc=uninstrumented fun:erfcf=uninstrumented fun:erfcf128=uninstrumented fun:erfcf32=uninstrumented fun:erfcf32x=uninstrumented fun:erfcf64=uninstrumented fun:erfcf64x=uninstrumented fun:erfcl=uninstrumented fun:erff=uninstrumented fun:erff128=uninstrumented fun:erff32=uninstrumented fun:erff32x=uninstrumented fun:erff64=uninstrumented fun:erff64x=uninstrumented fun:erfl=uninstrumented fun:err=uninstrumented fun:error=uninstrumented fun:error_at_line=uninstrumented fun:errx=uninstrumented fun:ether_aton=uninstrumented fun:ether_aton_r=uninstrumented fun:ether_hostton=uninstrumented fun:ether_line=uninstrumented fun:ether_ntoa=uninstrumented fun:ether_ntoa_r=uninstrumented fun:ether_ntohost=uninstrumented fun:euidaccess=uninstrumented fun:eventfd=uninstrumented fun:eventfd_read=uninstrumented fun:eventfd_write=uninstrumented fun:execl=uninstrumented fun:execle=uninstrumented fun:execlp=uninstrumented fun:execv=uninstrumented fun:execve=uninstrumented fun:execveat=uninstrumented fun:execvp=uninstrumented fun:execvpe=uninstrumented fun:exit=uninstrumented fun:exp=uninstrumented fun:exp10=uninstrumented fun:exp10f=uninstrumented fun:exp10f128=uninstrumented fun:exp10f32=uninstrumented fun:exp10f32x=uninstrumented fun:exp10f64=uninstrumented fun:exp10f64x=uninstrumented fun:exp10l=uninstrumented fun:exp2=uninstrumented fun:exp2f=uninstrumented fun:exp2f128=uninstrumented fun:exp2f32=uninstrumented fun:exp2f32x=uninstrumented fun:exp2f64=uninstrumented fun:exp2f64x=uninstrumented fun:exp2l=uninstrumented fun:expf=uninstrumented fun:expf128=uninstrumented fun:expf32=uninstrumented fun:expf32x=uninstrumented fun:expf64=uninstrumented fun:expf64x=uninstrumented fun:expl=uninstrumented fun:explicit_bzero=uninstrumented fun:expm1=uninstrumented fun:expm1f=uninstrumented fun:expm1f128=uninstrumented fun:expm1f32=uninstrumented fun:expm1f32x=uninstrumented fun:expm1f64=uninstrumented fun:expm1f64x=uninstrumented fun:expm1l=uninstrumented fun:f32addf128=uninstrumented fun:f32addf32x=uninstrumented fun:f32addf64=uninstrumented fun:f32addf64x=uninstrumented fun:f32divf128=uninstrumented fun:f32divf32x=uninstrumented fun:f32divf64=uninstrumented fun:f32divf64x=uninstrumented fun:f32fmaf128=uninstrumented fun:f32fmaf32x=uninstrumented fun:f32fmaf64=uninstrumented fun:f32fmaf64x=uninstrumented fun:f32mulf128=uninstrumented fun:f32mulf32x=uninstrumented fun:f32mulf64=uninstrumented fun:f32mulf64x=uninstrumented fun:f32sqrtf128=uninstrumented fun:f32sqrtf32x=uninstrumented fun:f32sqrtf64=uninstrumented fun:f32sqrtf64x=uninstrumented fun:f32subf128=uninstrumented fun:f32subf32x=uninstrumented fun:f32subf64=uninstrumented fun:f32subf64x=uninstrumented fun:f32xaddf128=uninstrumented fun:f32xaddf64=uninstrumented fun:f32xaddf64x=uninstrumented fun:f32xdivf128=uninstrumented fun:f32xdivf64=uninstrumented fun:f32xdivf64x=uninstrumented fun:f32xfmaf128=uninstrumented fun:f32xfmaf64=uninstrumented fun:f32xfmaf64x=uninstrumented fun:f32xmulf128=uninstrumented fun:f32xmulf64=uninstrumented fun:f32xmulf64x=uninstrumented fun:f32xsqrtf128=uninstrumented fun:f32xsqrtf64=uninstrumented fun:f32xsqrtf64x=uninstrumented fun:f32xsubf128=uninstrumented fun:f32xsubf64=uninstrumented fun:f32xsubf64x=uninstrumented fun:f64addf128=uninstrumented fun:f64addf64x=uninstrumented fun:f64divf128=uninstrumented fun:f64divf64x=uninstrumented fun:f64fmaf128=uninstrumented fun:f64fmaf64x=uninstrumented fun:f64mulf128=uninstrumented fun:f64mulf64x=uninstrumented fun:f64sqrtf128=uninstrumented fun:f64sqrtf64x=uninstrumented fun:f64subf128=uninstrumented fun:f64subf64x=uninstrumented fun:f64xaddf128=uninstrumented fun:f64xdivf128=uninstrumented fun:f64xfmaf128=uninstrumented fun:f64xmulf128=uninstrumented fun:f64xsqrtf128=uninstrumented fun:f64xsubf128=uninstrumented fun:fabs=uninstrumented fun:fabsf=uninstrumented fun:fabsf128=uninstrumented fun:fabsf32=uninstrumented fun:fabsf32x=uninstrumented fun:fabsf64=uninstrumented fun:fabsf64x=uninstrumented fun:fabsl=uninstrumented fun:faccessat=uninstrumented fun:fadd=uninstrumented fun:faddl=uninstrumented fun:fallocate=uninstrumented fun:fallocate64=uninstrumented fun:fanotify_init=uninstrumented fun:fanotify_mark=uninstrumented fun:fattach=uninstrumented fun:fchdir=uninstrumented fun:fchflags=uninstrumented fun:fchmod=uninstrumented fun:fchmodat=uninstrumented fun:fchown=uninstrumented fun:fchownat=uninstrumented fun:fclose=uninstrumented fun:fcloseall=uninstrumented fun:fcntl=uninstrumented fun:fcntl64=uninstrumented fun:fcrypt=uninstrumented fun:fcvt=uninstrumented fun:fcvt_r=uninstrumented fun:fdatasync=uninstrumented fun:fdetach=uninstrumented fun:fdim=uninstrumented fun:fdimf=uninstrumented fun:fdimf128=uninstrumented fun:fdimf32=uninstrumented fun:fdimf32x=uninstrumented fun:fdimf64=uninstrumented fun:fdimf64x=uninstrumented fun:fdiml=uninstrumented fun:fdiv=uninstrumented fun:fdivl=uninstrumented fun:fdopen=uninstrumented fun:fdopendir=uninstrumented fun:feclearexcept=uninstrumented fun:fedisableexcept=uninstrumented fun:feenableexcept=uninstrumented fun:fegetenv=uninstrumented fun:fegetexcept=uninstrumented fun:fegetexceptflag=uninstrumented fun:fegetmode=uninstrumented fun:fegetround=uninstrumented fun:feholdexcept=uninstrumented fun:feof=uninstrumented fun:feof_unlocked=uninstrumented fun:feraiseexcept=uninstrumented fun:ferror=uninstrumented fun:ferror_unlocked=uninstrumented fun:fesetenv=uninstrumented fun:fesetexcept=uninstrumented fun:fesetexceptflag=uninstrumented fun:fesetmode=uninstrumented fun:fesetround=uninstrumented fun:fetestexcept=uninstrumented fun:fetestexceptflag=uninstrumented fun:feupdateenv=uninstrumented fun:fexecve=uninstrumented fun:fflush=uninstrumented fun:fflush_unlocked=uninstrumented fun:ffma=uninstrumented fun:ffmal=uninstrumented fun:ffs=uninstrumented fun:ffsl=uninstrumented fun:ffsll=uninstrumented fun:fgetc=uninstrumented fun:fgetc_unlocked=uninstrumented fun:fgetgrent=uninstrumented fun:fgetgrent_r=uninstrumented fun:fgetpos=uninstrumented fun:fgetpos64=uninstrumented fun:fgetpwent=uninstrumented fun:fgetpwent_r=uninstrumented fun:fgets=uninstrumented fun:fgets_unlocked=uninstrumented fun:fgetsgent=uninstrumented fun:fgetsgent_r=uninstrumented fun:fgetspent=uninstrumented fun:fgetspent_r=uninstrumented fun:fgetwc=uninstrumented fun:fgetwc_unlocked=uninstrumented fun:fgetws=uninstrumented fun:fgetws_unlocked=uninstrumented fun:fgetxattr=uninstrumented fun:fileno=uninstrumented fun:fileno_unlocked=uninstrumented fun:finite=uninstrumented fun:finitef=uninstrumented fun:finitel=uninstrumented fun:flistxattr=uninstrumented fun:flock=uninstrumented fun:flockfile=uninstrumented fun:floor=uninstrumented fun:floorf=uninstrumented fun:floorf128=uninstrumented fun:floorf32=uninstrumented fun:floorf32x=uninstrumented fun:floorf64=uninstrumented fun:floorf64x=uninstrumented fun:floorl=uninstrumented fun:fma=uninstrumented fun:fmaf=uninstrumented fun:fmaf128=uninstrumented fun:fmaf32=uninstrumented fun:fmaf32x=uninstrumented fun:fmaf64=uninstrumented fun:fmaf64x=uninstrumented fun:fmal=uninstrumented fun:fmax=uninstrumented fun:fmaxf=uninstrumented fun:fmaxf128=uninstrumented fun:fmaxf32=uninstrumented fun:fmaxf32x=uninstrumented fun:fmaxf64=uninstrumented fun:fmaxf64x=uninstrumented fun:fmaximum=uninstrumented fun:fmaximum_mag=uninstrumented fun:fmaximum_mag_num=uninstrumented fun:fmaximum_mag_numf=uninstrumented fun:fmaximum_mag_numf128=uninstrumented fun:fmaximum_mag_numf32=uninstrumented fun:fmaximum_mag_numf32x=uninstrumented fun:fmaximum_mag_numf64=uninstrumented fun:fmaximum_mag_numf64x=uninstrumented fun:fmaximum_mag_numl=uninstrumented fun:fmaximum_magf=uninstrumented fun:fmaximum_magf128=uninstrumented fun:fmaximum_magf32=uninstrumented fun:fmaximum_magf32x=uninstrumented fun:fmaximum_magf64=uninstrumented fun:fmaximum_magf64x=uninstrumented fun:fmaximum_magl=uninstrumented fun:fmaximum_num=uninstrumented fun:fmaximum_numf=uninstrumented fun:fmaximum_numf128=uninstrumented fun:fmaximum_numf32=uninstrumented fun:fmaximum_numf32x=uninstrumented fun:fmaximum_numf64=uninstrumented fun:fmaximum_numf64x=uninstrumented fun:fmaximum_numl=uninstrumented fun:fmaximumf=uninstrumented fun:fmaximumf128=uninstrumented fun:fmaximumf32=uninstrumented fun:fmaximumf32x=uninstrumented fun:fmaximumf64=uninstrumented fun:fmaximumf64x=uninstrumented fun:fmaximuml=uninstrumented fun:fmaxl=uninstrumented fun:fmaxmag=uninstrumented fun:fmaxmagf=uninstrumented fun:fmaxmagf128=uninstrumented fun:fmaxmagf32=uninstrumented fun:fmaxmagf32x=uninstrumented fun:fmaxmagf64=uninstrumented fun:fmaxmagf64x=uninstrumented fun:fmaxmagl=uninstrumented fun:fmemopen=uninstrumented fun:fmin=uninstrumented fun:fminf=uninstrumented fun:fminf128=uninstrumented fun:fminf32=uninstrumented fun:fminf32x=uninstrumented fun:fminf64=uninstrumented fun:fminf64x=uninstrumented fun:fminimum=uninstrumented fun:fminimum_mag=uninstrumented fun:fminimum_mag_num=uninstrumented fun:fminimum_mag_numf=uninstrumented fun:fminimum_mag_numf128=uninstrumented fun:fminimum_mag_numf32=uninstrumented fun:fminimum_mag_numf32x=uninstrumented fun:fminimum_mag_numf64=uninstrumented fun:fminimum_mag_numf64x=uninstrumented fun:fminimum_mag_numl=uninstrumented fun:fminimum_magf=uninstrumented fun:fminimum_magf128=uninstrumented fun:fminimum_magf32=uninstrumented fun:fminimum_magf32x=uninstrumented fun:fminimum_magf64=uninstrumented fun:fminimum_magf64x=uninstrumented fun:fminimum_magl=uninstrumented fun:fminimum_num=uninstrumented fun:fminimum_numf=uninstrumented fun:fminimum_numf128=uninstrumented fun:fminimum_numf32=uninstrumented fun:fminimum_numf32x=uninstrumented fun:fminimum_numf64=uninstrumented fun:fminimum_numf64x=uninstrumented fun:fminimum_numl=uninstrumented fun:fminimumf=uninstrumented fun:fminimumf128=uninstrumented fun:fminimumf32=uninstrumented fun:fminimumf32x=uninstrumented fun:fminimumf64=uninstrumented fun:fminimumf64x=uninstrumented fun:fminimuml=uninstrumented fun:fminl=uninstrumented fun:fminmag=uninstrumented fun:fminmagf=uninstrumented fun:fminmagf128=uninstrumented fun:fminmagf32=uninstrumented fun:fminmagf32x=uninstrumented fun:fminmagf64=uninstrumented fun:fminmagf64x=uninstrumented fun:fminmagl=uninstrumented fun:fmod=uninstrumented fun:fmodf=uninstrumented fun:fmodf128=uninstrumented fun:fmodf32=uninstrumented fun:fmodf32x=uninstrumented fun:fmodf64=uninstrumented fun:fmodf64x=uninstrumented fun:fmodl=uninstrumented fun:fmtmsg=uninstrumented fun:fmul=uninstrumented fun:fmull=uninstrumented fun:fnmatch=uninstrumented fun:fopen=uninstrumented fun:fopen64=uninstrumented fun:fopencookie=uninstrumented fun:fork=uninstrumented fun:forkpty=uninstrumented fun:fpathconf=uninstrumented fun:fprintf=uninstrumented fun:fputc=uninstrumented fun:fputc_unlocked=uninstrumented fun:fputs=uninstrumented fun:fputs_unlocked=uninstrumented fun:fputwc=uninstrumented fun:fputwc_unlocked=uninstrumented fun:fputws=uninstrumented fun:fputws_unlocked=uninstrumented fun:fread=uninstrumented fun:fread_unlocked=uninstrumented fun:free=uninstrumented fun:freeaddrinfo=uninstrumented fun:freeifaddrs=uninstrumented fun:freelocale=uninstrumented fun:fremovexattr=uninstrumented fun:freopen=uninstrumented fun:freopen64=uninstrumented fun:frexp=uninstrumented fun:frexpf=uninstrumented fun:frexpf128=uninstrumented fun:frexpf32=uninstrumented fun:frexpf32x=uninstrumented fun:frexpf64=uninstrumented fun:frexpf64x=uninstrumented fun:frexpl=uninstrumented fun:fromfp=uninstrumented fun:fromfpf=uninstrumented fun:fromfpf128=uninstrumented fun:fromfpf32=uninstrumented fun:fromfpf32x=uninstrumented fun:fromfpf64=uninstrumented fun:fromfpf64x=uninstrumented fun:fromfpl=uninstrumented fun:fromfpx=uninstrumented fun:fromfpxf=uninstrumented fun:fromfpxf128=uninstrumented fun:fromfpxf32=uninstrumented fun:fromfpxf32x=uninstrumented fun:fromfpxf64=uninstrumented fun:fromfpxf64x=uninstrumented fun:fromfpxl=uninstrumented fun:fscanf=uninstrumented fun:fseek=uninstrumented fun:fseeko=uninstrumented fun:fseeko64=uninstrumented fun:fsetpos=uninstrumented fun:fsetpos64=uninstrumented fun:fsetxattr=uninstrumented fun:fsqrt=uninstrumented fun:fsqrtl=uninstrumented fun:fstat=uninstrumented fun:fstat64=uninstrumented fun:fstatat=uninstrumented fun:fstatat64=uninstrumented fun:fstatfs=uninstrumented fun:fstatfs64=uninstrumented fun:fstatvfs=uninstrumented fun:fstatvfs64=uninstrumented fun:fsub=uninstrumented fun:fsubl=uninstrumented fun:fsync=uninstrumented fun:ftell=uninstrumented fun:ftello=uninstrumented fun:ftello64=uninstrumented fun:ftime=uninstrumented fun:ftok=uninstrumented fun:ftruncate=uninstrumented fun:ftruncate64=uninstrumented fun:ftrylockfile=uninstrumented fun:fts64_children=uninstrumented fun:fts64_close=uninstrumented fun:fts64_open=uninstrumented fun:fts64_read=uninstrumented fun:fts64_set=uninstrumented fun:fts_children=uninstrumented fun:fts_close=uninstrumented fun:fts_open=uninstrumented fun:fts_read=uninstrumented fun:fts_set=uninstrumented fun:ftw=uninstrumented fun:ftw64=uninstrumented fun:funlockfile=uninstrumented fun:futimens=uninstrumented fun:futimes=uninstrumented fun:futimesat=uninstrumented fun:fwide=uninstrumented fun:fwprintf=uninstrumented fun:fwrite=uninstrumented fun:fwrite_unlocked=uninstrumented fun:fwscanf=uninstrumented fun:gai_cancel=uninstrumented fun:gai_error=uninstrumented fun:gai_strerror=uninstrumented fun:gai_suspend=uninstrumented fun:gamma=uninstrumented fun:gammaf=uninstrumented fun:gammal=uninstrumented fun:gcvt=uninstrumented fun:get_avphys_pages=uninstrumented fun:get_current_dir_name=uninstrumented fun:get_kernel_syms=uninstrumented fun:get_myaddress=uninstrumented fun:get_nprocs=uninstrumented fun:get_nprocs_conf=uninstrumented fun:get_phys_pages=uninstrumented fun:getaddrinfo=uninstrumented fun:getaddrinfo_a=uninstrumented fun:getaliasbyname=uninstrumented fun:getaliasbyname_r=uninstrumented fun:getaliasent=uninstrumented fun:getaliasent_r=uninstrumented fun:getauxval=uninstrumented fun:getc=uninstrumented fun:getc_unlocked=uninstrumented fun:getchar=uninstrumented fun:getchar_unlocked=uninstrumented fun:getcontext=uninstrumented fun:getcpu=uninstrumented fun:getcwd=uninstrumented fun:getdate=uninstrumented fun:getdate_r=uninstrumented fun:getdelim=uninstrumented fun:getdents64=uninstrumented fun:getdirentries=uninstrumented fun:getdirentries64=uninstrumented fun:getdomainname=uninstrumented fun:getdtablesize=uninstrumented fun:getegid=uninstrumented fun:getentropy=uninstrumented fun:getenv=uninstrumented fun:geteuid=uninstrumented fun:getfsent=uninstrumented fun:getfsfile=uninstrumented fun:getfsspec=uninstrumented fun:getgid=uninstrumented fun:getgrent=uninstrumented fun:getgrent_r=uninstrumented fun:getgrgid=uninstrumented fun:getgrgid_r=uninstrumented fun:getgrnam=uninstrumented fun:getgrnam_r=uninstrumented fun:getgrouplist=uninstrumented fun:getgroups=uninstrumented fun:gethostbyaddr=uninstrumented fun:gethostbyaddr_r=uninstrumented fun:gethostbyname=uninstrumented fun:gethostbyname2=uninstrumented fun:gethostbyname2_r=uninstrumented fun:gethostbyname_r=uninstrumented fun:gethostent=uninstrumented fun:gethostent_r=uninstrumented fun:gethostid=uninstrumented fun:gethostname=uninstrumented fun:getifaddrs=uninstrumented fun:getipv4sourcefilter=uninstrumented fun:getitimer=uninstrumented fun:getline=uninstrumented fun:getloadavg=uninstrumented fun:getlogin=uninstrumented fun:getlogin_r=uninstrumented fun:getmntent=uninstrumented fun:getmntent_r=uninstrumented fun:getmsg=uninstrumented fun:getnameinfo=uninstrumented fun:getnetbyaddr=uninstrumented fun:getnetbyaddr_r=uninstrumented fun:getnetbyname=uninstrumented fun:getnetbyname_r=uninstrumented fun:getnetent=uninstrumented fun:getnetent_r=uninstrumented fun:getnetgrent=uninstrumented fun:getnetgrent_r=uninstrumented fun:getnetname=uninstrumented fun:getopt=uninstrumented fun:getopt_long=uninstrumented fun:getopt_long_only=uninstrumented fun:getpagesize=uninstrumented fun:getpass=uninstrumented fun:getpayload=uninstrumented fun:getpayloadf=uninstrumented fun:getpayloadf128=uninstrumented fun:getpayloadf32=uninstrumented fun:getpayloadf32x=uninstrumented fun:getpayloadf64=uninstrumented fun:getpayloadf64x=uninstrumented fun:getpayloadl=uninstrumented fun:getpeername=uninstrumented fun:getpgid=uninstrumented fun:getpgrp=uninstrumented fun:getpid=uninstrumented fun:getpmsg=uninstrumented fun:getppid=uninstrumented fun:getpriority=uninstrumented fun:getprotobyname=uninstrumented fun:getprotobyname_r=uninstrumented fun:getprotobynumber=uninstrumented fun:getprotobynumber_r=uninstrumented fun:getprotoent=uninstrumented fun:getprotoent_r=uninstrumented fun:getpt=uninstrumented fun:getpublickey=uninstrumented fun:getpw=uninstrumented fun:getpwent=uninstrumented fun:getpwent_r=uninstrumented fun:getpwnam=uninstrumented fun:getpwnam_r=uninstrumented fun:getpwuid=uninstrumented fun:getpwuid_r=uninstrumented fun:getrandom=uninstrumented fun:getresgid=uninstrumented fun:getresuid=uninstrumented fun:getrlimit=uninstrumented fun:getrlimit64=uninstrumented fun:getrpcbyname=uninstrumented fun:getrpcbyname_r=uninstrumented fun:getrpcbynumber=uninstrumented fun:getrpcbynumber_r=uninstrumented fun:getrpcent=uninstrumented fun:getrpcent_r=uninstrumented fun:getrpcport=uninstrumented fun:getrusage=uninstrumented fun:gets=uninstrumented fun:getsecretkey=uninstrumented fun:getservbyname=uninstrumented fun:getservbyname_r=uninstrumented fun:getservbyport=uninstrumented fun:getservbyport_r=uninstrumented fun:getservent=uninstrumented fun:getservent_r=uninstrumented fun:getsgent=uninstrumented fun:getsgent_r=uninstrumented fun:getsgnam=uninstrumented fun:getsgnam_r=uninstrumented fun:getsid=uninstrumented fun:getsockname=uninstrumented fun:getsockopt=uninstrumented fun:getsourcefilter=uninstrumented fun:getspent=uninstrumented fun:getspent_r=uninstrumented fun:getspnam=uninstrumented fun:getspnam_r=uninstrumented fun:getsubopt=uninstrumented fun:gettext=uninstrumented fun:gettid=uninstrumented fun:gettimeofday=uninstrumented fun:getttyent=uninstrumented fun:getttynam=uninstrumented fun:getuid=uninstrumented fun:getusershell=uninstrumented fun:getutent=uninstrumented fun:getutent_r=uninstrumented fun:getutid=uninstrumented fun:getutid_r=uninstrumented fun:getutline=uninstrumented fun:getutline_r=uninstrumented fun:getutmp=uninstrumented fun:getutmpx=uninstrumented fun:getutxent=uninstrumented fun:getutxid=uninstrumented fun:getutxline=uninstrumented fun:getw=uninstrumented fun:getwc=uninstrumented fun:getwc_unlocked=uninstrumented fun:getwchar=uninstrumented fun:getwchar_unlocked=uninstrumented fun:getwd=uninstrumented fun:getxattr=uninstrumented fun:glob=uninstrumented fun:glob64=uninstrumented fun:glob_pattern_p=uninstrumented fun:globfree=uninstrumented fun:globfree64=uninstrumented fun:gmtime=uninstrumented fun:gmtime_r=uninstrumented fun:gnu_dev_major=uninstrumented fun:gnu_dev_makedev=uninstrumented fun:gnu_dev_minor=uninstrumented fun:gnu_get_libc_release=uninstrumented fun:gnu_get_libc_version=uninstrumented fun:grantpt=uninstrumented fun:group_member=uninstrumented fun:gsignal=uninstrumented fun:gtty=uninstrumented fun:hasmntopt=uninstrumented fun:hcreate=uninstrumented fun:hcreate_r=uninstrumented fun:hdestroy=uninstrumented fun:hdestroy_r=uninstrumented fun:herror=uninstrumented fun:host2netname=uninstrumented fun:hsearch=uninstrumented fun:hsearch_r=uninstrumented fun:hstrerror=uninstrumented fun:htonl=uninstrumented fun:htons=uninstrumented fun:hypot=uninstrumented fun:hypotf=uninstrumented fun:hypotf128=uninstrumented fun:hypotf32=uninstrumented fun:hypotf32x=uninstrumented fun:hypotf64=uninstrumented fun:hypotf64x=uninstrumented fun:hypotl=uninstrumented fun:iconv=uninstrumented fun:iconv_close=uninstrumented fun:iconv_open=uninstrumented fun:if_freenameindex=uninstrumented fun:if_indextoname=uninstrumented fun:if_nameindex=uninstrumented fun:if_nametoindex=uninstrumented fun:ilogb=uninstrumented fun:ilogbf=uninstrumented fun:ilogbf128=uninstrumented fun:ilogbf32=uninstrumented fun:ilogbf32x=uninstrumented fun:ilogbf64=uninstrumented fun:ilogbf64x=uninstrumented fun:ilogbl=uninstrumented fun:imaxabs=uninstrumented fun:imaxdiv=uninstrumented fun:index=uninstrumented fun:inet6_opt_append=uninstrumented fun:inet6_opt_find=uninstrumented fun:inet6_opt_finish=uninstrumented fun:inet6_opt_get_val=uninstrumented fun:inet6_opt_init=uninstrumented fun:inet6_opt_next=uninstrumented fun:inet6_opt_set_val=uninstrumented fun:inet6_option_alloc=uninstrumented fun:inet6_option_append=uninstrumented fun:inet6_option_find=uninstrumented fun:inet6_option_init=uninstrumented fun:inet6_option_next=uninstrumented fun:inet6_option_space=uninstrumented fun:inet6_rth_add=uninstrumented fun:inet6_rth_getaddr=uninstrumented fun:inet6_rth_init=uninstrumented fun:inet6_rth_reverse=uninstrumented fun:inet6_rth_segments=uninstrumented fun:inet6_rth_space=uninstrumented fun:inet_addr=uninstrumented fun:inet_aton=uninstrumented fun:inet_lnaof=uninstrumented fun:inet_makeaddr=uninstrumented fun:inet_net_ntop=uninstrumented fun:inet_net_pton=uninstrumented fun:inet_neta=uninstrumented fun:inet_netof=uninstrumented fun:inet_network=uninstrumented fun:inet_nsap_addr=uninstrumented fun:inet_nsap_ntoa=uninstrumented fun:inet_ntoa=uninstrumented fun:inet_ntop=uninstrumented fun:inet_pton=uninstrumented fun:init_module=uninstrumented fun:initgroups=uninstrumented fun:initstate=uninstrumented fun:initstate_r=uninstrumented fun:innetgr=uninstrumented fun:inotify_add_watch=uninstrumented fun:inotify_init=uninstrumented fun:inotify_init1=uninstrumented fun:inotify_rm_watch=uninstrumented fun:insque=uninstrumented fun:ioctl=uninstrumented fun:ioperm=uninstrumented fun:iopl=uninstrumented fun:iruserok=uninstrumented fun:iruserok_af=uninstrumented fun:isalnum=uninstrumented fun:isalnum_l=uninstrumented fun:isalpha=uninstrumented fun:isalpha_l=uninstrumented fun:isascii=uninstrumented fun:isastream=uninstrumented fun:isatty=uninstrumented fun:isblank=uninstrumented fun:isblank_l=uninstrumented fun:iscntrl=uninstrumented fun:iscntrl_l=uninstrumented fun:isctype=uninstrumented fun:isdigit=uninstrumented fun:isdigit_l=uninstrumented fun:isfdtype=uninstrumented fun:isgraph=uninstrumented fun:isgraph_l=uninstrumented fun:isinf=uninstrumented fun:isinfd128=uninstrumented fun:isinfd32=uninstrumented fun:isinfd64=uninstrumented fun:isinff=uninstrumented fun:isinfl=uninstrumented fun:islower=uninstrumented fun:islower_l=uninstrumented fun:isnan=uninstrumented fun:isnanf=uninstrumented fun:isnanl=uninstrumented fun:isprint=uninstrumented fun:isprint_l=uninstrumented fun:ispunct=uninstrumented fun:ispunct_l=uninstrumented fun:isspace=uninstrumented fun:isspace_l=uninstrumented fun:isupper=uninstrumented fun:isupper_l=uninstrumented fun:iswalnum=uninstrumented fun:iswalnum_l=uninstrumented fun:iswalpha=uninstrumented fun:iswalpha_l=uninstrumented fun:iswblank=uninstrumented fun:iswblank_l=uninstrumented fun:iswcntrl=uninstrumented fun:iswcntrl_l=uninstrumented fun:iswctype=uninstrumented fun:iswctype_l=uninstrumented fun:iswdigit=uninstrumented fun:iswdigit_l=uninstrumented fun:iswgraph=uninstrumented fun:iswgraph_l=uninstrumented fun:iswlower=uninstrumented fun:iswlower_l=uninstrumented fun:iswprint=uninstrumented fun:iswprint_l=uninstrumented fun:iswpunct=uninstrumented fun:iswpunct_l=uninstrumented fun:iswspace=uninstrumented fun:iswspace_l=uninstrumented fun:iswupper=uninstrumented fun:iswupper_l=uninstrumented fun:iswxdigit=uninstrumented fun:iswxdigit_l=uninstrumented fun:isxdigit=uninstrumented fun:isxdigit_l=uninstrumented fun:j0=uninstrumented fun:j0f=uninstrumented fun:j0f128=uninstrumented fun:j0f32=uninstrumented fun:j0f32x=uninstrumented fun:j0f64=uninstrumented fun:j0f64x=uninstrumented fun:j0l=uninstrumented fun:j1=uninstrumented fun:j1f=uninstrumented fun:j1f128=uninstrumented fun:j1f32=uninstrumented fun:j1f32x=uninstrumented fun:j1f64=uninstrumented fun:j1f64x=uninstrumented fun:j1l=uninstrumented fun:jn=uninstrumented fun:jnf=uninstrumented fun:jnf128=uninstrumented fun:jnf32=uninstrumented fun:jnf32x=uninstrumented fun:jnf64=uninstrumented fun:jnf64x=uninstrumented fun:jnl=uninstrumented fun:jrand48=uninstrumented fun:jrand48_r=uninstrumented fun:key_decryptsession=uninstrumented fun:key_decryptsession_pk=uninstrumented fun:key_encryptsession=uninstrumented fun:key_encryptsession_pk=uninstrumented fun:key_gendes=uninstrumented fun:key_get_conv=uninstrumented fun:key_secretkey_is_set=uninstrumented fun:key_setnet=uninstrumented fun:key_setsecret=uninstrumented fun:kill=uninstrumented fun:killpg=uninstrumented fun:klogctl=uninstrumented fun:l64a=uninstrumented fun:labs=uninstrumented fun:lchmod=uninstrumented fun:lchown=uninstrumented fun:lckpwdf=uninstrumented fun:lcong48=uninstrumented fun:lcong48_r=uninstrumented fun:ldexp=uninstrumented fun:ldexpf=uninstrumented fun:ldexpf128=uninstrumented fun:ldexpf32=uninstrumented fun:ldexpf32x=uninstrumented fun:ldexpf64=uninstrumented fun:ldexpf64x=uninstrumented fun:ldexpl=uninstrumented fun:ldiv=uninstrumented fun:lfind=uninstrumented fun:lgamma=uninstrumented fun:lgamma_r=uninstrumented fun:lgammaf=uninstrumented fun:lgammaf128=uninstrumented fun:lgammaf128_r=uninstrumented fun:lgammaf32=uninstrumented fun:lgammaf32_r=uninstrumented fun:lgammaf32x=uninstrumented fun:lgammaf32x_r=uninstrumented fun:lgammaf64=uninstrumented fun:lgammaf64_r=uninstrumented fun:lgammaf64x=uninstrumented fun:lgammaf64x_r=uninstrumented fun:lgammaf_r=uninstrumented fun:lgammal=uninstrumented fun:lgammal_r=uninstrumented fun:lgetxattr=uninstrumented fun:link=uninstrumented fun:linkat=uninstrumented fun:lio_listio=uninstrumented fun:lio_listio64=uninstrumented fun:listen=uninstrumented fun:listxattr=uninstrumented fun:llabs=uninstrumented fun:lldiv=uninstrumented fun:llistxattr=uninstrumented fun:llogb=uninstrumented fun:llogbf=uninstrumented fun:llogbf128=uninstrumented fun:llogbf32=uninstrumented fun:llogbf32x=uninstrumented fun:llogbf64=uninstrumented fun:llogbf64x=uninstrumented fun:llogbl=uninstrumented fun:llrint=uninstrumented fun:llrintf=uninstrumented fun:llrintf128=uninstrumented fun:llrintf32=uninstrumented fun:llrintf32x=uninstrumented fun:llrintf64=uninstrumented fun:llrintf64x=uninstrumented fun:llrintl=uninstrumented fun:llround=uninstrumented fun:llroundf=uninstrumented fun:llroundf128=uninstrumented fun:llroundf32=uninstrumented fun:llroundf32x=uninstrumented fun:llroundf64=uninstrumented fun:llroundf64x=uninstrumented fun:llroundl=uninstrumented fun:llseek=uninstrumented fun:localeconv=uninstrumented fun:localtime=uninstrumented fun:localtime_r=uninstrumented fun:lockf=uninstrumented fun:lockf64=uninstrumented fun:log=uninstrumented fun:log10=uninstrumented fun:log10f=uninstrumented fun:log10f128=uninstrumented fun:log10f32=uninstrumented fun:log10f32x=uninstrumented fun:log10f64=uninstrumented fun:log10f64x=uninstrumented fun:log10l=uninstrumented fun:log1p=uninstrumented fun:log1pf=uninstrumented fun:log1pf128=uninstrumented fun:log1pf32=uninstrumented fun:log1pf32x=uninstrumented fun:log1pf64=uninstrumented fun:log1pf64x=uninstrumented fun:log1pl=uninstrumented fun:log2=uninstrumented fun:log2f=uninstrumented fun:log2f128=uninstrumented fun:log2f32=uninstrumented fun:log2f32x=uninstrumented fun:log2f64=uninstrumented fun:log2f64x=uninstrumented fun:log2l=uninstrumented fun:logb=uninstrumented fun:logbf=uninstrumented fun:logbf128=uninstrumented fun:logbf32=uninstrumented fun:logbf32x=uninstrumented fun:logbf64=uninstrumented fun:logbf64x=uninstrumented fun:logbl=uninstrumented fun:logf=uninstrumented fun:logf128=uninstrumented fun:logf32=uninstrumented fun:logf32x=uninstrumented fun:logf64=uninstrumented fun:logf64x=uninstrumented fun:login=uninstrumented fun:login_tty=uninstrumented fun:logl=uninstrumented fun:logout=uninstrumented fun:logwtmp=uninstrumented fun:longjmp=uninstrumented fun:lrand48=uninstrumented fun:lrand48_r=uninstrumented fun:lremovexattr=uninstrumented fun:lrint=uninstrumented fun:lrintf=uninstrumented fun:lrintf128=uninstrumented fun:lrintf32=uninstrumented fun:lrintf32x=uninstrumented fun:lrintf64=uninstrumented fun:lrintf64x=uninstrumented fun:lrintl=uninstrumented fun:lround=uninstrumented fun:lroundf=uninstrumented fun:lroundf128=uninstrumented fun:lroundf32=uninstrumented fun:lroundf32x=uninstrumented fun:lroundf64=uninstrumented fun:lroundf64x=uninstrumented fun:lroundl=uninstrumented fun:lsearch=uninstrumented fun:lseek=uninstrumented fun:lseek64=uninstrumented fun:lsetxattr=uninstrumented fun:lstat=uninstrumented fun:lstat64=uninstrumented fun:lutimes=uninstrumented fun:madvise=uninstrumented fun:makecontext=uninstrumented fun:mallinfo=uninstrumented fun:mallinfo2=uninstrumented fun:malloc=uninstrumented fun:malloc_info=uninstrumented fun:malloc_stats=uninstrumented fun:malloc_trim=uninstrumented fun:malloc_usable_size=uninstrumented fun:mallopt=uninstrumented fun:matherr=uninstrumented fun:mblen=uninstrumented fun:mbrlen=uninstrumented fun:mbrtoc16=uninstrumented fun:mbrtoc32=uninstrumented fun:mbrtowc=uninstrumented fun:mbsinit=uninstrumented fun:mbsnrtowcs=uninstrumented fun:mbsrtowcs=uninstrumented fun:mbstowcs=uninstrumented fun:mbtowc=uninstrumented fun:mcheck=uninstrumented fun:mcheck_check_all=uninstrumented fun:mcheck_pedantic=uninstrumented fun:mcount=uninstrumented fun:memalign=uninstrumented fun:memccpy=uninstrumented fun:memchr=uninstrumented fun:memcmp=uninstrumented fun:memcpy=uninstrumented fun:memfd_create=uninstrumented fun:memfrob=uninstrumented fun:memmem=uninstrumented fun:memmove=uninstrumented fun:mempcpy=uninstrumented fun:memrchr=uninstrumented fun:memset=uninstrumented fun:mincore=uninstrumented fun:mkdir=uninstrumented fun:mkdirat=uninstrumented fun:mkdtemp=uninstrumented fun:mkfifo=uninstrumented fun:mkfifoat=uninstrumented fun:mknod=uninstrumented fun:mknodat=uninstrumented fun:mkostemp=uninstrumented fun:mkostemp64=uninstrumented fun:mkostemps=uninstrumented fun:mkostemps64=uninstrumented fun:mkstemp=uninstrumented fun:mkstemp64=uninstrumented fun:mkstemps=uninstrumented fun:mkstemps64=uninstrumented fun:mktemp=uninstrumented fun:mktime=uninstrumented fun:mlock=uninstrumented fun:mlock2=uninstrumented fun:mlockall=uninstrumented fun:mmap=uninstrumented fun:mmap64=uninstrumented fun:modf=uninstrumented fun:modff=uninstrumented fun:modff128=uninstrumented fun:modff32=uninstrumented fun:modff32x=uninstrumented fun:modff64=uninstrumented fun:modff64x=uninstrumented fun:modfl=uninstrumented fun:modify_ldt=uninstrumented fun:moncontrol=uninstrumented fun:monstartup=uninstrumented fun:mount=uninstrumented fun:mprobe=uninstrumented fun:mprotect=uninstrumented fun:mq_close=uninstrumented fun:mq_getattr=uninstrumented fun:mq_notify=uninstrumented fun:mq_open=uninstrumented fun:mq_receive=uninstrumented fun:mq_send=uninstrumented fun:mq_setattr=uninstrumented fun:mq_timedreceive=uninstrumented fun:mq_timedsend=uninstrumented fun:mq_unlink=uninstrumented fun:mrand48=uninstrumented fun:mrand48_r=uninstrumented fun:mremap=uninstrumented fun:msgctl=uninstrumented fun:msgget=uninstrumented fun:msgrcv=uninstrumented fun:msgsnd=uninstrumented fun:msync=uninstrumented fun:mtrace=uninstrumented fun:mtx_destroy=uninstrumented fun:mtx_init=uninstrumented fun:mtx_lock=uninstrumented fun:mtx_timedlock=uninstrumented fun:mtx_trylock=uninstrumented fun:mtx_unlock=uninstrumented fun:munlock=uninstrumented fun:munlockall=uninstrumented fun:munmap=uninstrumented fun:muntrace=uninstrumented fun:name_to_handle_at=uninstrumented fun:nan=uninstrumented fun:nanf=uninstrumented fun:nanf128=uninstrumented fun:nanf32=uninstrumented fun:nanf32x=uninstrumented fun:nanf64=uninstrumented fun:nanf64x=uninstrumented fun:nanl=uninstrumented fun:nanosleep=uninstrumented fun:nearbyint=uninstrumented fun:nearbyintf=uninstrumented fun:nearbyintf128=uninstrumented fun:nearbyintf32=uninstrumented fun:nearbyintf32x=uninstrumented fun:nearbyintf64=uninstrumented fun:nearbyintf64x=uninstrumented fun:nearbyintl=uninstrumented fun:netname2host=uninstrumented fun:netname2user=uninstrumented fun:newlocale=uninstrumented fun:nextafter=uninstrumented fun:nextafterf=uninstrumented fun:nextafterf128=uninstrumented fun:nextafterf32=uninstrumented fun:nextafterf32x=uninstrumented fun:nextafterf64=uninstrumented fun:nextafterf64x=uninstrumented fun:nextafterl=uninstrumented fun:nextdown=uninstrumented fun:nextdownf=uninstrumented fun:nextdownf128=uninstrumented fun:nextdownf32=uninstrumented fun:nextdownf32x=uninstrumented fun:nextdownf64=uninstrumented fun:nextdownf64x=uninstrumented fun:nextdownl=uninstrumented fun:nexttoward=uninstrumented fun:nexttowardf=uninstrumented fun:nexttowardl=uninstrumented fun:nextup=uninstrumented fun:nextupf=uninstrumented fun:nextupf128=uninstrumented fun:nextupf32=uninstrumented fun:nextupf32x=uninstrumented fun:nextupf64=uninstrumented fun:nextupf64x=uninstrumented fun:nextupl=uninstrumented fun:nfsservctl=uninstrumented fun:nftw=uninstrumented fun:nftw64=uninstrumented fun:ngettext=uninstrumented fun:nice=uninstrumented fun:nis_add=uninstrumented fun:nis_add_entry=uninstrumented fun:nis_addmember=uninstrumented fun:nis_checkpoint=uninstrumented fun:nis_clone_directory=uninstrumented fun:nis_clone_object=uninstrumented fun:nis_clone_result=uninstrumented fun:nis_creategroup=uninstrumented fun:nis_destroy_object=uninstrumented fun:nis_destroygroup=uninstrumented fun:nis_dir_cmp=uninstrumented fun:nis_domain_of=uninstrumented fun:nis_domain_of_r=uninstrumented fun:nis_first_entry=uninstrumented fun:nis_free_directory=uninstrumented fun:nis_free_object=uninstrumented fun:nis_free_request=uninstrumented fun:nis_freenames=uninstrumented fun:nis_freeresult=uninstrumented fun:nis_freeservlist=uninstrumented fun:nis_freetags=uninstrumented fun:nis_getnames=uninstrumented fun:nis_getservlist=uninstrumented fun:nis_ismember=uninstrumented fun:nis_leaf_of=uninstrumented fun:nis_leaf_of_r=uninstrumented fun:nis_lerror=uninstrumented fun:nis_list=uninstrumented fun:nis_local_directory=uninstrumented fun:nis_local_group=uninstrumented fun:nis_local_host=uninstrumented fun:nis_local_principal=uninstrumented fun:nis_lookup=uninstrumented fun:nis_mkdir=uninstrumented fun:nis_modify=uninstrumented fun:nis_modify_entry=uninstrumented fun:nis_name_of=uninstrumented fun:nis_name_of_r=uninstrumented fun:nis_next_entry=uninstrumented fun:nis_perror=uninstrumented fun:nis_ping=uninstrumented fun:nis_print_directory=uninstrumented fun:nis_print_entry=uninstrumented fun:nis_print_group=uninstrumented fun:nis_print_group_entry=uninstrumented fun:nis_print_link=uninstrumented fun:nis_print_object=uninstrumented fun:nis_print_result=uninstrumented fun:nis_print_rights=uninstrumented fun:nis_print_table=uninstrumented fun:nis_read_obj=uninstrumented fun:nis_remove=uninstrumented fun:nis_remove_entry=uninstrumented fun:nis_removemember=uninstrumented fun:nis_rmdir=uninstrumented fun:nis_servstate=uninstrumented fun:nis_sperrno=uninstrumented fun:nis_sperror=uninstrumented fun:nis_sperror_r=uninstrumented fun:nis_stats=uninstrumented fun:nis_verifygroup=uninstrumented fun:nis_write_obj=uninstrumented fun:nl_langinfo=uninstrumented fun:nl_langinfo_l=uninstrumented fun:nrand48=uninstrumented fun:nrand48_r=uninstrumented fun:ns_datetosecs=uninstrumented fun:ns_format_ttl=uninstrumented fun:ns_get16=uninstrumented fun:ns_get32=uninstrumented fun:ns_initparse=uninstrumented fun:ns_makecanon=uninstrumented fun:ns_msg_getflag=uninstrumented fun:ns_name_compress=uninstrumented fun:ns_name_ntol=uninstrumented fun:ns_name_ntop=uninstrumented fun:ns_name_pack=uninstrumented fun:ns_name_pton=uninstrumented fun:ns_name_rollback=uninstrumented fun:ns_name_skip=uninstrumented fun:ns_name_uncompress=uninstrumented fun:ns_name_unpack=uninstrumented fun:ns_parse_ttl=uninstrumented fun:ns_parserr=uninstrumented fun:ns_put16=uninstrumented fun:ns_put32=uninstrumented fun:ns_samedomain=uninstrumented fun:ns_samename=uninstrumented fun:ns_skiprr=uninstrumented fun:ns_sprintrr=uninstrumented fun:ns_sprintrrf=uninstrumented fun:ns_subdomain=uninstrumented fun:ntohl=uninstrumented fun:ntohs=uninstrumented fun:ntp_adjtime=uninstrumented fun:ntp_gettime=uninstrumented fun:ntp_gettimex=uninstrumented fun:obstack_free=uninstrumented fun:obstack_printf=uninstrumented fun:obstack_vprintf=uninstrumented fun:on_exit=uninstrumented fun:open=uninstrumented fun:open64=uninstrumented fun:open_by_handle_at=uninstrumented fun:open_memstream=uninstrumented fun:open_wmemstream=uninstrumented fun:openat=uninstrumented fun:openat64=uninstrumented fun:opendir=uninstrumented fun:openlog=uninstrumented fun:openpty=uninstrumented fun:parse_printf_format=uninstrumented fun:passwd2des=uninstrumented fun:pathconf=uninstrumented fun:pause=uninstrumented fun:pclose=uninstrumented fun:perror=uninstrumented fun:personality=uninstrumented fun:pipe=uninstrumented fun:pipe2=uninstrumented fun:pivot_root=uninstrumented fun:pkey_alloc=uninstrumented fun:pkey_free=uninstrumented fun:pkey_get=uninstrumented fun:pkey_mprotect=uninstrumented fun:pkey_set=uninstrumented fun:pmap_getmaps=uninstrumented fun:pmap_getport=uninstrumented fun:pmap_rmtcall=uninstrumented fun:pmap_set=uninstrumented fun:pmap_unset=uninstrumented fun:poll=uninstrumented fun:popen=uninstrumented fun:posix_fadvise=uninstrumented fun:posix_fadvise64=uninstrumented fun:posix_fallocate=uninstrumented fun:posix_fallocate64=uninstrumented fun:posix_madvise=uninstrumented fun:posix_memalign=uninstrumented fun:posix_openpt=uninstrumented fun:posix_spawn=uninstrumented fun:posix_spawn_file_actions_addchdir_np=uninstrumented fun:posix_spawn_file_actions_addclose=uninstrumented fun:posix_spawn_file_actions_addclosefrom_np=uninstrumented fun:posix_spawn_file_actions_adddup2=uninstrumented fun:posix_spawn_file_actions_addfchdir_np=uninstrumented fun:posix_spawn_file_actions_addopen=uninstrumented fun:posix_spawn_file_actions_addtcsetpgrp_np=uninstrumented fun:posix_spawn_file_actions_destroy=uninstrumented fun:posix_spawn_file_actions_init=uninstrumented fun:posix_spawnattr_destroy=uninstrumented fun:posix_spawnattr_getflags=uninstrumented fun:posix_spawnattr_getpgroup=uninstrumented fun:posix_spawnattr_getschedparam=uninstrumented fun:posix_spawnattr_getschedpolicy=uninstrumented fun:posix_spawnattr_getsigdefault=uninstrumented fun:posix_spawnattr_getsigmask=uninstrumented fun:posix_spawnattr_init=uninstrumented fun:posix_spawnattr_setflags=uninstrumented fun:posix_spawnattr_setpgroup=uninstrumented fun:posix_spawnattr_setschedparam=uninstrumented fun:posix_spawnattr_setschedpolicy=uninstrumented fun:posix_spawnattr_setsigdefault=uninstrumented fun:posix_spawnattr_setsigmask=uninstrumented fun:posix_spawnp=uninstrumented fun:pow=uninstrumented fun:pow10=uninstrumented fun:pow10f=uninstrumented fun:pow10l=uninstrumented fun:powf=uninstrumented fun:powf128=uninstrumented fun:powf32=uninstrumented fun:powf32x=uninstrumented fun:powf64=uninstrumented fun:powf64x=uninstrumented fun:powl=uninstrumented fun:ppoll=uninstrumented fun:prctl=uninstrumented fun:pread=uninstrumented fun:pread64=uninstrumented fun:preadv=uninstrumented fun:preadv2=uninstrumented fun:preadv64=uninstrumented fun:preadv64v2=uninstrumented fun:printf=uninstrumented fun:printf_size=uninstrumented fun:printf_size_info=uninstrumented fun:prlimit=uninstrumented fun:prlimit64=uninstrumented fun:process_vm_readv=uninstrumented fun:process_vm_writev=uninstrumented fun:profil=uninstrumented fun:pselect=uninstrumented fun:psiginfo=uninstrumented fun:psignal=uninstrumented fun:pthread_atfork=uninstrumented fun:pthread_attr_destroy=uninstrumented fun:pthread_attr_getaffinity_np=uninstrumented fun:pthread_attr_getdetachstate=uninstrumented fun:pthread_attr_getguardsize=uninstrumented fun:pthread_attr_getinheritsched=uninstrumented fun:pthread_attr_getschedparam=uninstrumented fun:pthread_attr_getschedpolicy=uninstrumented fun:pthread_attr_getscope=uninstrumented fun:pthread_attr_getsigmask_np=uninstrumented fun:pthread_attr_getstack=uninstrumented fun:pthread_attr_getstackaddr=uninstrumented fun:pthread_attr_getstacksize=uninstrumented fun:pthread_attr_init=uninstrumented fun:pthread_attr_setaffinity_np=uninstrumented fun:pthread_attr_setdetachstate=uninstrumented fun:pthread_attr_setguardsize=uninstrumented fun:pthread_attr_setinheritsched=uninstrumented fun:pthread_attr_setschedparam=uninstrumented fun:pthread_attr_setschedpolicy=uninstrumented fun:pthread_attr_setscope=uninstrumented fun:pthread_attr_setsigmask_np=uninstrumented fun:pthread_attr_setstack=uninstrumented fun:pthread_attr_setstackaddr=uninstrumented fun:pthread_attr_setstacksize=uninstrumented fun:pthread_barrier_destroy=uninstrumented fun:pthread_barrier_init=uninstrumented fun:pthread_barrier_wait=uninstrumented fun:pthread_barrierattr_destroy=uninstrumented fun:pthread_barrierattr_getpshared=uninstrumented fun:pthread_barrierattr_init=uninstrumented fun:pthread_barrierattr_setpshared=uninstrumented fun:pthread_cancel=uninstrumented fun:pthread_clockjoin_np=uninstrumented fun:pthread_cond_broadcast=uninstrumented fun:pthread_cond_clockwait=uninstrumented fun:pthread_cond_destroy=uninstrumented fun:pthread_cond_init=uninstrumented fun:pthread_cond_signal=uninstrumented fun:pthread_cond_timedwait=uninstrumented fun:pthread_cond_wait=uninstrumented fun:pthread_condattr_destroy=uninstrumented fun:pthread_condattr_getclock=uninstrumented fun:pthread_condattr_getpshared=uninstrumented fun:pthread_condattr_init=uninstrumented fun:pthread_condattr_setclock=uninstrumented fun:pthread_condattr_setpshared=uninstrumented fun:pthread_create=uninstrumented fun:pthread_detach=uninstrumented fun:pthread_equal=uninstrumented fun:pthread_exit=uninstrumented fun:pthread_getaffinity_np=uninstrumented fun:pthread_getattr_default_np=uninstrumented fun:pthread_getattr_np=uninstrumented fun:pthread_getconcurrency=uninstrumented fun:pthread_getcpuclockid=uninstrumented fun:pthread_getname_np=uninstrumented fun:pthread_getschedparam=uninstrumented fun:pthread_getspecific=uninstrumented fun:pthread_join=uninstrumented fun:pthread_key_create=uninstrumented fun:pthread_key_delete=uninstrumented fun:pthread_kill=uninstrumented fun:pthread_kill_other_threads_np=uninstrumented fun:pthread_mutex_clocklock=uninstrumented fun:pthread_mutex_consistent=uninstrumented fun:pthread_mutex_consistent_np=uninstrumented fun:pthread_mutex_destroy=uninstrumented fun:pthread_mutex_getprioceiling=uninstrumented fun:pthread_mutex_init=uninstrumented fun:pthread_mutex_lock=uninstrumented fun:pthread_mutex_setprioceiling=uninstrumented fun:pthread_mutex_timedlock=uninstrumented fun:pthread_mutex_trylock=uninstrumented fun:pthread_mutex_unlock=uninstrumented fun:pthread_mutexattr_destroy=uninstrumented fun:pthread_mutexattr_getkind_np=uninstrumented fun:pthread_mutexattr_getprioceiling=uninstrumented fun:pthread_mutexattr_getprotocol=uninstrumented fun:pthread_mutexattr_getpshared=uninstrumented fun:pthread_mutexattr_getrobust=uninstrumented fun:pthread_mutexattr_getrobust_np=uninstrumented fun:pthread_mutexattr_gettype=uninstrumented fun:pthread_mutexattr_init=uninstrumented fun:pthread_mutexattr_setkind_np=uninstrumented fun:pthread_mutexattr_setprioceiling=uninstrumented fun:pthread_mutexattr_setprotocol=uninstrumented fun:pthread_mutexattr_setpshared=uninstrumented fun:pthread_mutexattr_setrobust=uninstrumented fun:pthread_mutexattr_setrobust_np=uninstrumented fun:pthread_mutexattr_settype=uninstrumented fun:pthread_once=uninstrumented fun:pthread_rwlock_clockrdlock=uninstrumented fun:pthread_rwlock_clockwrlock=uninstrumented fun:pthread_rwlock_destroy=uninstrumented fun:pthread_rwlock_init=uninstrumented fun:pthread_rwlock_rdlock=uninstrumented fun:pthread_rwlock_timedrdlock=uninstrumented fun:pthread_rwlock_timedwrlock=uninstrumented fun:pthread_rwlock_tryrdlock=uninstrumented fun:pthread_rwlock_trywrlock=uninstrumented fun:pthread_rwlock_unlock=uninstrumented fun:pthread_rwlock_wrlock=uninstrumented fun:pthread_rwlockattr_destroy=uninstrumented fun:pthread_rwlockattr_getkind_np=uninstrumented fun:pthread_rwlockattr_getpshared=uninstrumented fun:pthread_rwlockattr_init=uninstrumented fun:pthread_rwlockattr_setkind_np=uninstrumented fun:pthread_rwlockattr_setpshared=uninstrumented fun:pthread_self=uninstrumented fun:pthread_setaffinity_np=uninstrumented fun:pthread_setattr_default_np=uninstrumented fun:pthread_setcancelstate=uninstrumented fun:pthread_setcanceltype=uninstrumented fun:pthread_setconcurrency=uninstrumented fun:pthread_setname_np=uninstrumented fun:pthread_setschedparam=uninstrumented fun:pthread_setschedprio=uninstrumented fun:pthread_setspecific=uninstrumented fun:pthread_sigmask=uninstrumented fun:pthread_sigqueue=uninstrumented fun:pthread_spin_destroy=uninstrumented fun:pthread_spin_init=uninstrumented fun:pthread_spin_lock=uninstrumented fun:pthread_spin_trylock=uninstrumented fun:pthread_spin_unlock=uninstrumented fun:pthread_testcancel=uninstrumented fun:pthread_timedjoin_np=uninstrumented fun:pthread_tryjoin_np=uninstrumented fun:pthread_yield=uninstrumented fun:ptrace=uninstrumented fun:ptsname=uninstrumented fun:ptsname_r=uninstrumented fun:putc=uninstrumented fun:putc_unlocked=uninstrumented fun:putchar=uninstrumented fun:putchar_unlocked=uninstrumented fun:putenv=uninstrumented fun:putgrent=uninstrumented fun:putmsg=uninstrumented fun:putpmsg=uninstrumented fun:putpwent=uninstrumented fun:puts=uninstrumented fun:putsgent=uninstrumented fun:putspent=uninstrumented fun:pututline=uninstrumented fun:pututxline=uninstrumented fun:putw=uninstrumented fun:putwc=uninstrumented fun:putwc_unlocked=uninstrumented fun:putwchar=uninstrumented fun:putwchar_unlocked=uninstrumented fun:pvalloc=uninstrumented fun:pwrite=uninstrumented fun:pwrite64=uninstrumented fun:pwritev=uninstrumented fun:pwritev2=uninstrumented fun:pwritev64=uninstrumented fun:pwritev64v2=uninstrumented fun:qecvt=uninstrumented fun:qecvt_r=uninstrumented fun:qfcvt=uninstrumented fun:qfcvt_r=uninstrumented fun:qgcvt=uninstrumented fun:qsort=uninstrumented fun:qsort_r=uninstrumented fun:query_module=uninstrumented fun:quick_exit=uninstrumented fun:quotactl=uninstrumented fun:raise=uninstrumented fun:rand=uninstrumented fun:rand_r=uninstrumented fun:random=uninstrumented fun:random_r=uninstrumented fun:rawmemchr=uninstrumented fun:rcmd=uninstrumented fun:rcmd_af=uninstrumented fun:re_comp=uninstrumented fun:re_compile_fastmap=uninstrumented fun:re_compile_pattern=uninstrumented fun:re_exec=uninstrumented fun:re_match=uninstrumented fun:re_match_2=uninstrumented fun:re_search=uninstrumented fun:re_search_2=uninstrumented fun:re_set_registers=uninstrumented fun:re_set_syntax=uninstrumented fun:read=uninstrumented fun:readColdStartFile=uninstrumented fun:readahead=uninstrumented fun:readdir=uninstrumented fun:readdir64=uninstrumented fun:readdir64_r=uninstrumented fun:readdir_r=uninstrumented fun:readlink=uninstrumented fun:readlinkat=uninstrumented fun:readv=uninstrumented fun:realloc=uninstrumented fun:reallocarray=uninstrumented fun:realpath=uninstrumented fun:reboot=uninstrumented fun:recv=uninstrumented fun:recvfrom=uninstrumented fun:recvmmsg=uninstrumented fun:recvmsg=uninstrumented fun:regcomp=uninstrumented fun:regerror=uninstrumented fun:regexec=uninstrumented fun:regfree=uninstrumented fun:register_printf_function=uninstrumented fun:register_printf_modifier=uninstrumented fun:register_printf_specifier=uninstrumented fun:register_printf_type=uninstrumented fun:registerrpc=uninstrumented fun:remainder=uninstrumented fun:remainderf=uninstrumented fun:remainderf128=uninstrumented fun:remainderf32=uninstrumented fun:remainderf32x=uninstrumented fun:remainderf64=uninstrumented fun:remainderf64x=uninstrumented fun:remainderl=uninstrumented fun:remap_file_pages=uninstrumented fun:remove=uninstrumented fun:removexattr=uninstrumented fun:remque=uninstrumented fun:remquo=uninstrumented fun:remquof=uninstrumented fun:remquof128=uninstrumented fun:remquof32=uninstrumented fun:remquof32x=uninstrumented fun:remquof64=uninstrumented fun:remquof64x=uninstrumented fun:remquol=uninstrumented fun:rename=uninstrumented fun:renameat=uninstrumented fun:renameat2=uninstrumented fun:res_dnok=uninstrumented fun:res_gethostbyaddr=uninstrumented fun:res_gethostbyname=uninstrumented fun:res_gethostbyname2=uninstrumented fun:res_hnok=uninstrumented fun:res_mailok=uninstrumented fun:res_mkquery=uninstrumented fun:res_nmkquery=uninstrumented fun:res_nquery=uninstrumented fun:res_nquerydomain=uninstrumented fun:res_nsearch=uninstrumented fun:res_nsend=uninstrumented fun:res_ownok=uninstrumented fun:res_query=uninstrumented fun:res_querydomain=uninstrumented fun:res_search=uninstrumented fun:res_send=uninstrumented fun:res_send_setqhook=uninstrumented fun:res_send_setrhook=uninstrumented fun:revoke=uninstrumented fun:rewind=uninstrumented fun:rewinddir=uninstrumented fun:rexec=uninstrumented fun:rexec_af=uninstrumented fun:rindex=uninstrumented fun:rint=uninstrumented fun:rintf=uninstrumented fun:rintf128=uninstrumented fun:rintf32=uninstrumented fun:rintf32x=uninstrumented fun:rintf64=uninstrumented fun:rintf64x=uninstrumented fun:rintl=uninstrumented fun:rmdir=uninstrumented fun:round=uninstrumented fun:roundeven=uninstrumented fun:roundevenf=uninstrumented fun:roundevenf128=uninstrumented fun:roundevenf32=uninstrumented fun:roundevenf32x=uninstrumented fun:roundevenf64=uninstrumented fun:roundevenf64x=uninstrumented fun:roundevenl=uninstrumented fun:roundf=uninstrumented fun:roundf128=uninstrumented fun:roundf32=uninstrumented fun:roundf32x=uninstrumented fun:roundf64=uninstrumented fun:roundf64x=uninstrumented fun:roundl=uninstrumented fun:rpmatch=uninstrumented fun:rresvport=uninstrumented fun:rresvport_af=uninstrumented fun:rtime=uninstrumented fun:ruserok=uninstrumented fun:ruserok_af=uninstrumented fun:ruserpass=uninstrumented fun:sbrk=uninstrumented fun:scalb=uninstrumented fun:scalbf=uninstrumented fun:scalbl=uninstrumented fun:scalbln=uninstrumented fun:scalblnf=uninstrumented fun:scalblnf128=uninstrumented fun:scalblnf32=uninstrumented fun:scalblnf32x=uninstrumented fun:scalblnf64=uninstrumented fun:scalblnf64x=uninstrumented fun:scalblnl=uninstrumented fun:scalbn=uninstrumented fun:scalbnf=uninstrumented fun:scalbnf128=uninstrumented fun:scalbnf32=uninstrumented fun:scalbnf32x=uninstrumented fun:scalbnf64=uninstrumented fun:scalbnf64x=uninstrumented fun:scalbnl=uninstrumented fun:scandir=uninstrumented fun:scandir64=uninstrumented fun:scandirat=uninstrumented fun:scandirat64=uninstrumented fun:scanf=uninstrumented fun:sched_get_priority_max=uninstrumented fun:sched_get_priority_min=uninstrumented fun:sched_getaffinity=uninstrumented fun:sched_getcpu=uninstrumented fun:sched_getparam=uninstrumented fun:sched_getscheduler=uninstrumented fun:sched_rr_get_interval=uninstrumented fun:sched_setaffinity=uninstrumented fun:sched_setparam=uninstrumented fun:sched_setscheduler=uninstrumented fun:sched_yield=uninstrumented fun:secure_getenv=uninstrumented fun:seed48=uninstrumented fun:seed48_r=uninstrumented fun:seekdir=uninstrumented fun:select=uninstrumented fun:sem_clockwait=uninstrumented fun:sem_close=uninstrumented fun:sem_destroy=uninstrumented fun:sem_getvalue=uninstrumented fun:sem_init=uninstrumented fun:sem_open=uninstrumented fun:sem_post=uninstrumented fun:sem_timedwait=uninstrumented fun:sem_trywait=uninstrumented fun:sem_unlink=uninstrumented fun:sem_wait=uninstrumented fun:semctl=uninstrumented fun:semget=uninstrumented fun:semop=uninstrumented fun:semtimedop=uninstrumented fun:send=uninstrumented fun:sendfile=uninstrumented fun:sendfile64=uninstrumented fun:sendmmsg=uninstrumented fun:sendmsg=uninstrumented fun:sendto=uninstrumented fun:setaliasent=uninstrumented fun:setbuf=uninstrumented fun:setbuffer=uninstrumented fun:setcontext=uninstrumented fun:setdomainname=uninstrumented fun:setegid=uninstrumented fun:setenv=uninstrumented fun:seteuid=uninstrumented fun:setfsent=uninstrumented fun:setfsgid=uninstrumented fun:setfsuid=uninstrumented fun:setgid=uninstrumented fun:setgrent=uninstrumented fun:setgroups=uninstrumented fun:sethostent=uninstrumented fun:sethostid=uninstrumented fun:sethostname=uninstrumented fun:setipv4sourcefilter=uninstrumented fun:setitimer=uninstrumented fun:setjmp=uninstrumented fun:setkey=uninstrumented fun:setkey_r=uninstrumented fun:setlinebuf=uninstrumented fun:setlocale=uninstrumented fun:setlogin=uninstrumented fun:setlogmask=uninstrumented fun:setmntent=uninstrumented fun:setnetent=uninstrumented fun:setnetgrent=uninstrumented fun:setns=uninstrumented fun:setpayload=uninstrumented fun:setpayloadf=uninstrumented fun:setpayloadf128=uninstrumented fun:setpayloadf32=uninstrumented fun:setpayloadf32x=uninstrumented fun:setpayloadf64=uninstrumented fun:setpayloadf64x=uninstrumented fun:setpayloadl=uninstrumented fun:setpayloadsig=uninstrumented fun:setpayloadsigf=uninstrumented fun:setpayloadsigf128=uninstrumented fun:setpayloadsigf32=uninstrumented fun:setpayloadsigf32x=uninstrumented fun:setpayloadsigf64=uninstrumented fun:setpayloadsigf64x=uninstrumented fun:setpayloadsigl=uninstrumented fun:setpgid=uninstrumented fun:setpgrp=uninstrumented fun:setpriority=uninstrumented fun:setprotoent=uninstrumented fun:setpwent=uninstrumented fun:setregid=uninstrumented fun:setresgid=uninstrumented fun:setresuid=uninstrumented fun:setreuid=uninstrumented fun:setrlimit=uninstrumented fun:setrlimit64=uninstrumented fun:setrpcent=uninstrumented fun:setservent=uninstrumented fun:setsgent=uninstrumented fun:setsid=uninstrumented fun:setsockopt=uninstrumented fun:setsourcefilter=uninstrumented fun:setspent=uninstrumented fun:setstate=uninstrumented fun:setstate_r=uninstrumented fun:settimeofday=uninstrumented fun:setttyent=uninstrumented fun:setuid=uninstrumented fun:setusershell=uninstrumented fun:setutent=uninstrumented fun:setutxent=uninstrumented fun:setvbuf=uninstrumented fun:setxattr=uninstrumented fun:sgetsgent=uninstrumented fun:sgetsgent_r=uninstrumented fun:sgetspent=uninstrumented fun:sgetspent_r=uninstrumented fun:shm_open=uninstrumented fun:shm_unlink=uninstrumented fun:shmat=uninstrumented fun:shmctl=uninstrumented fun:shmdt=uninstrumented fun:shmget=uninstrumented fun:shutdown=uninstrumented fun:sigabbrev_np=uninstrumented fun:sigaction=uninstrumented fun:sigaddset=uninstrumented fun:sigaltstack=uninstrumented fun:sigandset=uninstrumented fun:sigblock=uninstrumented fun:sigdelset=uninstrumented fun:sigdescr_np=uninstrumented fun:sigemptyset=uninstrumented fun:sigfillset=uninstrumented fun:siggetmask=uninstrumented fun:sighold=uninstrumented fun:sigignore=uninstrumented fun:siginterrupt=uninstrumented fun:sigisemptyset=uninstrumented fun:sigismember=uninstrumented fun:siglongjmp=uninstrumented fun:signal=uninstrumented fun:signalfd=uninstrumented fun:significand=uninstrumented fun:significandf=uninstrumented fun:significandl=uninstrumented fun:sigorset=uninstrumented fun:sigpause=uninstrumented fun:sigpending=uninstrumented fun:sigprocmask=uninstrumented fun:sigqueue=uninstrumented fun:sigrelse=uninstrumented fun:sigreturn=uninstrumented fun:sigset=uninstrumented fun:sigsetmask=uninstrumented fun:sigstack=uninstrumented fun:sigsuspend=uninstrumented fun:sigtimedwait=uninstrumented fun:sigvec=uninstrumented fun:sigwait=uninstrumented fun:sigwaitinfo=uninstrumented fun:sin=uninstrumented fun:sincos=uninstrumented fun:sincosf=uninstrumented fun:sincosf128=uninstrumented fun:sincosf32=uninstrumented fun:sincosf32x=uninstrumented fun:sincosf64=uninstrumented fun:sincosf64x=uninstrumented fun:sincosl=uninstrumented fun:sinf=uninstrumented fun:sinf128=uninstrumented fun:sinf32=uninstrumented fun:sinf32x=uninstrumented fun:sinf64=uninstrumented fun:sinf64x=uninstrumented fun:sinh=uninstrumented fun:sinhf=uninstrumented fun:sinhf128=uninstrumented fun:sinhf32=uninstrumented fun:sinhf32x=uninstrumented fun:sinhf64=uninstrumented fun:sinhf64x=uninstrumented fun:sinhl=uninstrumented fun:sinl=uninstrumented fun:sleep=uninstrumented fun:snprintf=uninstrumented fun:sockatmark=uninstrumented fun:socket=uninstrumented fun:socketpair=uninstrumented fun:splice=uninstrumented fun:sprintf=uninstrumented fun:sprofil=uninstrumented fun:sqrt=uninstrumented fun:sqrtf=uninstrumented fun:sqrtf128=uninstrumented fun:sqrtf32=uninstrumented fun:sqrtf32x=uninstrumented fun:sqrtf64=uninstrumented fun:sqrtf64x=uninstrumented fun:sqrtl=uninstrumented fun:srand=uninstrumented fun:srand48=uninstrumented fun:srand48_r=uninstrumented fun:srandom=uninstrumented fun:srandom_r=uninstrumented fun:sscanf=uninstrumented fun:ssignal=uninstrumented fun:sstk=uninstrumented fun:stat=uninstrumented fun:stat64=uninstrumented fun:statfs=uninstrumented fun:statfs64=uninstrumented fun:statvfs=uninstrumented fun:statvfs64=uninstrumented fun:statx=uninstrumented fun:step=uninstrumented fun:stime=uninstrumented fun:stpcpy=uninstrumented fun:stpncpy=uninstrumented fun:strcasecmp=uninstrumented fun:strcasecmp_l=uninstrumented fun:strcasestr=uninstrumented fun:strcat=uninstrumented fun:strchr=uninstrumented fun:strchrnul=uninstrumented fun:strcmp=uninstrumented fun:strcoll=uninstrumented fun:strcoll_l=uninstrumented fun:strcpy=uninstrumented fun:strcspn=uninstrumented fun:strdup=uninstrumented fun:strerror=uninstrumented fun:strerror_l=uninstrumented fun:strerror_r=uninstrumented fun:strerrordesc_np=uninstrumented fun:strerrorname_np=uninstrumented fun:strfmon=uninstrumented fun:strfmon_l=uninstrumented fun:strfromd=uninstrumented fun:strfromf=uninstrumented fun:strfromf128=uninstrumented fun:strfromf32=uninstrumented fun:strfromf32x=uninstrumented fun:strfromf64=uninstrumented fun:strfromf64x=uninstrumented fun:strfroml=uninstrumented fun:strfry=uninstrumented fun:strftime=uninstrumented fun:strftime_l=uninstrumented fun:strlen=uninstrumented fun:strncasecmp=uninstrumented fun:strncasecmp_l=uninstrumented fun:strncat=uninstrumented fun:strncmp=uninstrumented fun:strncpy=uninstrumented fun:strndup=uninstrumented fun:strnlen=uninstrumented fun:strpbrk=uninstrumented fun:strptime=uninstrumented fun:strptime_l=uninstrumented fun:strrchr=uninstrumented fun:strsep=uninstrumented fun:strsignal=uninstrumented fun:strspn=uninstrumented fun:strstr=uninstrumented fun:strtod=uninstrumented fun:strtod_l=uninstrumented fun:strtof=uninstrumented fun:strtof128=uninstrumented fun:strtof128_l=uninstrumented fun:strtof32=uninstrumented fun:strtof32_l=uninstrumented fun:strtof32x=uninstrumented fun:strtof32x_l=uninstrumented fun:strtof64=uninstrumented fun:strtof64_l=uninstrumented fun:strtof64x=uninstrumented fun:strtof64x_l=uninstrumented fun:strtof_l=uninstrumented fun:strtoimax=uninstrumented fun:strtok=uninstrumented fun:strtok_r=uninstrumented fun:strtol=uninstrumented fun:strtol_l=uninstrumented fun:strtold=uninstrumented fun:strtold_l=uninstrumented fun:strtoll=uninstrumented fun:strtoll_l=uninstrumented fun:strtoq=uninstrumented fun:strtoul=uninstrumented fun:strtoul_l=uninstrumented fun:strtoull=uninstrumented fun:strtoull_l=uninstrumented fun:strtoumax=uninstrumented fun:strtouq=uninstrumented fun:strverscmp=uninstrumented fun:strxfrm=uninstrumented fun:strxfrm_l=uninstrumented fun:stty=uninstrumented fun:svc_exit=uninstrumented fun:svc_getreq=uninstrumented fun:svc_getreq_common=uninstrumented fun:svc_getreq_poll=uninstrumented fun:svc_getreqset=uninstrumented fun:svc_register=uninstrumented fun:svc_run=uninstrumented fun:svc_sendreply=uninstrumented fun:svc_unregister=uninstrumented fun:svcerr_auth=uninstrumented fun:svcerr_decode=uninstrumented fun:svcerr_noproc=uninstrumented fun:svcerr_noprog=uninstrumented fun:svcerr_progvers=uninstrumented fun:svcerr_systemerr=uninstrumented fun:svcerr_weakauth=uninstrumented fun:svcfd_create=uninstrumented fun:svcraw_create=uninstrumented fun:svctcp_create=uninstrumented fun:svcudp_bufcreate=uninstrumented fun:svcudp_create=uninstrumented fun:svcudp_enablecache=uninstrumented fun:svcunix_create=uninstrumented fun:svcunixfd_create=uninstrumented fun:swab=uninstrumented fun:swapcontext=uninstrumented fun:swapoff=uninstrumented fun:swapon=uninstrumented fun:swprintf=uninstrumented fun:swscanf=uninstrumented fun:symlink=uninstrumented fun:symlinkat=uninstrumented fun:sync=uninstrumented fun:sync_file_range=uninstrumented fun:syncfs=uninstrumented fun:syscall=uninstrumented fun:sysconf=uninstrumented fun:sysctl=uninstrumented fun:sysinfo=uninstrumented fun:syslog=uninstrumented fun:system=uninstrumented fun:sysv_signal=uninstrumented fun:tan=uninstrumented fun:tanf=uninstrumented fun:tanf128=uninstrumented fun:tanf32=uninstrumented fun:tanf32x=uninstrumented fun:tanf64=uninstrumented fun:tanf64x=uninstrumented fun:tanh=uninstrumented fun:tanhf=uninstrumented fun:tanhf128=uninstrumented fun:tanhf32=uninstrumented fun:tanhf32x=uninstrumented fun:tanhf64=uninstrumented fun:tanhf64x=uninstrumented fun:tanhl=uninstrumented fun:tanl=uninstrumented fun:tcdrain=uninstrumented fun:tcflow=uninstrumented fun:tcflush=uninstrumented fun:tcgetattr=uninstrumented fun:tcgetpgrp=uninstrumented fun:tcgetsid=uninstrumented fun:tcsendbreak=uninstrumented fun:tcsetattr=uninstrumented fun:tcsetpgrp=uninstrumented fun:td_init=uninstrumented fun:td_log=uninstrumented fun:td_symbol_list=uninstrumented fun:td_ta_clear_event=uninstrumented fun:td_ta_delete=uninstrumented fun:td_ta_enable_stats=uninstrumented fun:td_ta_event_addr=uninstrumented fun:td_ta_event_getmsg=uninstrumented fun:td_ta_get_nthreads=uninstrumented fun:td_ta_get_ph=uninstrumented fun:td_ta_get_stats=uninstrumented fun:td_ta_map_id2thr=uninstrumented fun:td_ta_map_lwp2thr=uninstrumented fun:td_ta_new=uninstrumented fun:td_ta_reset_stats=uninstrumented fun:td_ta_set_event=uninstrumented fun:td_ta_setconcurrency=uninstrumented fun:td_ta_thr_iter=uninstrumented fun:td_ta_tsd_iter=uninstrumented fun:td_thr_clear_event=uninstrumented fun:td_thr_dbresume=uninstrumented fun:td_thr_dbsuspend=uninstrumented fun:td_thr_event_enable=uninstrumented fun:td_thr_event_getmsg=uninstrumented fun:td_thr_get_info=uninstrumented fun:td_thr_getfpregs=uninstrumented fun:td_thr_getgregs=uninstrumented fun:td_thr_getxregs=uninstrumented fun:td_thr_getxregsize=uninstrumented fun:td_thr_set_event=uninstrumented fun:td_thr_setfpregs=uninstrumented fun:td_thr_setgregs=uninstrumented fun:td_thr_setprio=uninstrumented fun:td_thr_setsigpending=uninstrumented fun:td_thr_setxregs=uninstrumented fun:td_thr_sigsetmask=uninstrumented fun:td_thr_tls_get_addr=uninstrumented fun:td_thr_tlsbase=uninstrumented fun:td_thr_tsd=uninstrumented fun:td_thr_validate=uninstrumented fun:tdelete=uninstrumented fun:tdestroy=uninstrumented fun:tee=uninstrumented fun:telldir=uninstrumented fun:tempnam=uninstrumented fun:textdomain=uninstrumented fun:tfind=uninstrumented fun:tgamma=uninstrumented fun:tgammaf=uninstrumented fun:tgammaf128=uninstrumented fun:tgammaf32=uninstrumented fun:tgammaf32x=uninstrumented fun:tgammaf64=uninstrumented fun:tgammaf64x=uninstrumented fun:tgammal=uninstrumented fun:tgkill=uninstrumented fun:thrd_create=uninstrumented fun:thrd_current=uninstrumented fun:thrd_detach=uninstrumented fun:thrd_equal=uninstrumented fun:thrd_exit=uninstrumented fun:thrd_join=uninstrumented fun:thrd_sleep=uninstrumented fun:thrd_yield=uninstrumented fun:time=uninstrumented fun:timegm=uninstrumented fun:timelocal=uninstrumented fun:timer_create=uninstrumented fun:timer_delete=uninstrumented fun:timer_getoverrun=uninstrumented fun:timer_gettime=uninstrumented fun:timer_settime=uninstrumented fun:timerfd_create=uninstrumented fun:timerfd_gettime=uninstrumented fun:timerfd_settime=uninstrumented fun:times=uninstrumented fun:timespec_get=uninstrumented fun:timespec_getres=uninstrumented fun:tmpfile=uninstrumented fun:tmpfile64=uninstrumented fun:tmpnam=uninstrumented fun:tmpnam_r=uninstrumented fun:toascii=uninstrumented fun:tolower=uninstrumented fun:tolower_l=uninstrumented fun:totalorder=uninstrumented fun:totalorderf=uninstrumented fun:totalorderf128=uninstrumented fun:totalorderf32=uninstrumented fun:totalorderf32x=uninstrumented fun:totalorderf64=uninstrumented fun:totalorderf64x=uninstrumented fun:totalorderl=uninstrumented fun:totalordermag=uninstrumented fun:totalordermagf=uninstrumented fun:totalordermagf128=uninstrumented fun:totalordermagf32=uninstrumented fun:totalordermagf32x=uninstrumented fun:totalordermagf64=uninstrumented fun:totalordermagf64x=uninstrumented fun:totalordermagl=uninstrumented fun:toupper=uninstrumented fun:toupper_l=uninstrumented fun:towctrans=uninstrumented fun:towctrans_l=uninstrumented fun:towlower=uninstrumented fun:towlower_l=uninstrumented fun:towupper=uninstrumented fun:towupper_l=uninstrumented fun:tr_break=uninstrumented fun:trunc=uninstrumented fun:truncate=uninstrumented fun:truncate64=uninstrumented fun:truncf=uninstrumented fun:truncf128=uninstrumented fun:truncf32=uninstrumented fun:truncf32x=uninstrumented fun:truncf64=uninstrumented fun:truncf64x=uninstrumented fun:truncl=uninstrumented fun:tsearch=uninstrumented fun:tss_create=uninstrumented fun:tss_delete=uninstrumented fun:tss_get=uninstrumented fun:tss_set=uninstrumented fun:ttyname=uninstrumented fun:ttyname_r=uninstrumented fun:ttyslot=uninstrumented fun:twalk=uninstrumented fun:twalk_r=uninstrumented fun:tzset=uninstrumented fun:ualarm=uninstrumented fun:ufromfp=uninstrumented fun:ufromfpf=uninstrumented fun:ufromfpf128=uninstrumented fun:ufromfpf32=uninstrumented fun:ufromfpf32x=uninstrumented fun:ufromfpf64=uninstrumented fun:ufromfpf64x=uninstrumented fun:ufromfpl=uninstrumented fun:ufromfpx=uninstrumented fun:ufromfpxf=uninstrumented fun:ufromfpxf128=uninstrumented fun:ufromfpxf32=uninstrumented fun:ufromfpxf32x=uninstrumented fun:ufromfpxf64=uninstrumented fun:ufromfpxf64x=uninstrumented fun:ufromfpxl=uninstrumented fun:ulckpwdf=uninstrumented fun:ulimit=uninstrumented fun:umask=uninstrumented fun:umount=uninstrumented fun:umount2=uninstrumented fun:uname=uninstrumented fun:ungetc=uninstrumented fun:ungetwc=uninstrumented fun:unlink=uninstrumented fun:unlinkat=uninstrumented fun:unlockpt=uninstrumented fun:unsetenv=uninstrumented fun:unshare=uninstrumented fun:updwtmp=uninstrumented fun:updwtmpx=uninstrumented fun:uselib=uninstrumented fun:uselocale=uninstrumented fun:user2netname=uninstrumented fun:usleep=uninstrumented fun:ustat=uninstrumented fun:utime=uninstrumented fun:utimensat=uninstrumented fun:utimes=uninstrumented fun:utmpname=uninstrumented fun:utmpxname=uninstrumented fun:valloc=uninstrumented fun:vasprintf=uninstrumented fun:vdprintf=uninstrumented fun:verr=uninstrumented fun:verrx=uninstrumented fun:versionsort=uninstrumented fun:versionsort64=uninstrumented fun:vfork=uninstrumented fun:vfprintf=uninstrumented fun:vfscanf=uninstrumented fun:vfwprintf=uninstrumented fun:vfwscanf=uninstrumented fun:vhangup=uninstrumented fun:vlimit=uninstrumented fun:vmsplice=uninstrumented fun:vprintf=uninstrumented fun:vscanf=uninstrumented fun:vsnprintf=uninstrumented fun:vsprintf=uninstrumented fun:vsscanf=uninstrumented fun:vswprintf=uninstrumented fun:vswscanf=uninstrumented fun:vsyslog=uninstrumented fun:vtimes=uninstrumented fun:vwarn=uninstrumented fun:vwarnx=uninstrumented fun:vwprintf=uninstrumented fun:vwscanf=uninstrumented fun:wait=uninstrumented fun:wait3=uninstrumented fun:wait4=uninstrumented fun:waitid=uninstrumented fun:waitpid=uninstrumented fun:warn=uninstrumented fun:warnx=uninstrumented fun:wcpcpy=uninstrumented fun:wcpncpy=uninstrumented fun:wcrtomb=uninstrumented fun:wcscasecmp=uninstrumented fun:wcscasecmp_l=uninstrumented fun:wcscat=uninstrumented fun:wcschr=uninstrumented fun:wcschrnul=uninstrumented fun:wcscmp=uninstrumented fun:wcscoll=uninstrumented fun:wcscoll_l=uninstrumented fun:wcscpy=uninstrumented fun:wcscspn=uninstrumented fun:wcsdup=uninstrumented fun:wcsftime=uninstrumented fun:wcsftime_l=uninstrumented fun:wcslen=uninstrumented fun:wcsncasecmp=uninstrumented fun:wcsncasecmp_l=uninstrumented fun:wcsncat=uninstrumented fun:wcsncmp=uninstrumented fun:wcsncpy=uninstrumented fun:wcsnlen=uninstrumented fun:wcsnrtombs=uninstrumented fun:wcspbrk=uninstrumented fun:wcsrchr=uninstrumented fun:wcsrtombs=uninstrumented fun:wcsspn=uninstrumented fun:wcsstr=uninstrumented fun:wcstod=uninstrumented fun:wcstod_l=uninstrumented fun:wcstof=uninstrumented fun:wcstof128=uninstrumented fun:wcstof128_l=uninstrumented fun:wcstof32=uninstrumented fun:wcstof32_l=uninstrumented fun:wcstof32x=uninstrumented fun:wcstof32x_l=uninstrumented fun:wcstof64=uninstrumented fun:wcstof64_l=uninstrumented fun:wcstof64x=uninstrumented fun:wcstof64x_l=uninstrumented fun:wcstof_l=uninstrumented fun:wcstoimax=uninstrumented fun:wcstok=uninstrumented fun:wcstol=uninstrumented fun:wcstol_l=uninstrumented fun:wcstold=uninstrumented fun:wcstold_l=uninstrumented fun:wcstoll=uninstrumented fun:wcstoll_l=uninstrumented fun:wcstombs=uninstrumented fun:wcstoq=uninstrumented fun:wcstoul=uninstrumented fun:wcstoul_l=uninstrumented fun:wcstoull=uninstrumented fun:wcstoull_l=uninstrumented fun:wcstoumax=uninstrumented fun:wcstouq=uninstrumented fun:wcswcs=uninstrumented fun:wcswidth=uninstrumented fun:wcsxfrm=uninstrumented fun:wcsxfrm_l=uninstrumented fun:wctob=uninstrumented fun:wctomb=uninstrumented fun:wctrans=uninstrumented fun:wctrans_l=uninstrumented fun:wctype=uninstrumented fun:wctype_l=uninstrumented fun:wcwidth=uninstrumented fun:wmemchr=uninstrumented fun:wmemcmp=uninstrumented fun:wmemcpy=uninstrumented fun:wmemmove=uninstrumented fun:wmempcpy=uninstrumented fun:wmemset=uninstrumented fun:wordexp=uninstrumented fun:wordfree=uninstrumented fun:wprintf=uninstrumented fun:write=uninstrumented fun:writeColdStartFile=uninstrumented fun:writev=uninstrumented fun:wscanf=uninstrumented fun:xcrypt=uninstrumented fun:xcrypt_gensalt=uninstrumented fun:xcrypt_gensalt_r=uninstrumented fun:xcrypt_r=uninstrumented fun:xdecrypt=uninstrumented fun:xdr_accepted_reply=uninstrumented fun:xdr_array=uninstrumented fun:xdr_authdes_cred=uninstrumented fun:xdr_authdes_verf=uninstrumented fun:xdr_authunix_parms=uninstrumented fun:xdr_bool=uninstrumented fun:xdr_bytes=uninstrumented fun:xdr_callhdr=uninstrumented fun:xdr_callmsg=uninstrumented fun:xdr_cback_data=uninstrumented fun:xdr_char=uninstrumented fun:xdr_cryptkeyarg=uninstrumented fun:xdr_cryptkeyarg2=uninstrumented fun:xdr_cryptkeyres=uninstrumented fun:xdr_des_block=uninstrumented fun:xdr_domainname=uninstrumented fun:xdr_double=uninstrumented fun:xdr_enum=uninstrumented fun:xdr_float=uninstrumented fun:xdr_free=uninstrumented fun:xdr_getcredres=uninstrumented fun:xdr_hyper=uninstrumented fun:xdr_int=uninstrumented fun:xdr_int16_t=uninstrumented fun:xdr_int32_t=uninstrumented fun:xdr_int64_t=uninstrumented fun:xdr_int8_t=uninstrumented fun:xdr_key_netstarg=uninstrumented fun:xdr_key_netstres=uninstrumented fun:xdr_keybuf=uninstrumented fun:xdr_keydat=uninstrumented fun:xdr_keystatus=uninstrumented fun:xdr_long=uninstrumented fun:xdr_longlong_t=uninstrumented fun:xdr_mapname=uninstrumented fun:xdr_netnamestr=uninstrumented fun:xdr_netobj=uninstrumented fun:xdr_obj_p=uninstrumented fun:xdr_opaque=uninstrumented fun:xdr_opaque_auth=uninstrumented fun:xdr_peername=uninstrumented fun:xdr_pmap=uninstrumented fun:xdr_pmaplist=uninstrumented fun:xdr_pointer=uninstrumented fun:xdr_quad_t=uninstrumented fun:xdr_reference=uninstrumented fun:xdr_rejected_reply=uninstrumented fun:xdr_replymsg=uninstrumented fun:xdr_rmtcall_args=uninstrumented fun:xdr_rmtcallres=uninstrumented fun:xdr_short=uninstrumented fun:xdr_sizeof=uninstrumented fun:xdr_string=uninstrumented fun:xdr_u_char=uninstrumented fun:xdr_u_hyper=uninstrumented fun:xdr_u_int=uninstrumented fun:xdr_u_long=uninstrumented fun:xdr_u_longlong_t=uninstrumented fun:xdr_u_quad_t=uninstrumented fun:xdr_u_short=uninstrumented fun:xdr_uint16_t=uninstrumented fun:xdr_uint32_t=uninstrumented fun:xdr_uint64_t=uninstrumented fun:xdr_uint8_t=uninstrumented fun:xdr_union=uninstrumented fun:xdr_unixcred=uninstrumented fun:xdr_valdat=uninstrumented fun:xdr_vector=uninstrumented fun:xdr_void=uninstrumented fun:xdr_wrapstring=uninstrumented fun:xdr_yp_buf=uninstrumented fun:xdr_ypall=uninstrumented fun:xdr_ypbind_binding=uninstrumented fun:xdr_ypbind_resp=uninstrumented fun:xdr_ypbind_resptype=uninstrumented fun:xdr_ypbind_setdom=uninstrumented fun:xdr_ypdelete_args=uninstrumented fun:xdr_ypmap_parms=uninstrumented fun:xdr_ypmaplist=uninstrumented fun:xdr_yppush_status=uninstrumented fun:xdr_yppushresp_xfr=uninstrumented fun:xdr_ypreq_key=uninstrumented fun:xdr_ypreq_nokey=uninstrumented fun:xdr_ypreq_xfr=uninstrumented fun:xdr_ypresp_all=uninstrumented fun:xdr_ypresp_key_val=uninstrumented fun:xdr_ypresp_maplist=uninstrumented fun:xdr_ypresp_master=uninstrumented fun:xdr_ypresp_order=uninstrumented fun:xdr_ypresp_val=uninstrumented fun:xdr_ypresp_xfr=uninstrumented fun:xdr_ypstat=uninstrumented fun:xdr_ypupdate_args=uninstrumented fun:xdr_ypxfrstat=uninstrumented fun:xdrmem_create=uninstrumented fun:xdrrec_create=uninstrumented fun:xdrrec_endofrecord=uninstrumented fun:xdrrec_eof=uninstrumented fun:xdrrec_skiprecord=uninstrumented fun:xdrstdio_create=uninstrumented fun:xencrypt=uninstrumented fun:xprt_register=uninstrumented fun:xprt_unregister=uninstrumented fun:y0=uninstrumented fun:y0f=uninstrumented fun:y0f128=uninstrumented fun:y0f32=uninstrumented fun:y0f32x=uninstrumented fun:y0f64=uninstrumented fun:y0f64x=uninstrumented fun:y0l=uninstrumented fun:y1=uninstrumented fun:y1f=uninstrumented fun:y1f128=uninstrumented fun:y1f32=uninstrumented fun:y1f32x=uninstrumented fun:y1f64=uninstrumented fun:y1f64x=uninstrumented fun:y1l=uninstrumented fun:yn=uninstrumented fun:ynf=uninstrumented fun:ynf128=uninstrumented fun:ynf32=uninstrumented fun:ynf32x=uninstrumented fun:ynf64=uninstrumented fun:ynf64x=uninstrumented fun:ynl=uninstrumented fun:yp_all=uninstrumented fun:yp_bind=uninstrumented fun:yp_first=uninstrumented fun:yp_get_default_domain=uninstrumented fun:yp_maplist=uninstrumented fun:yp_master=uninstrumented fun:yp_match=uninstrumented fun:yp_next=uninstrumented fun:yp_order=uninstrumented fun:yp_unbind=uninstrumented fun:yp_update=uninstrumented fun:ypbinderr_string=uninstrumented fun:yperr_string=uninstrumented fun:ypprot_err=uninstrumented ================================================ FILE: runtime/dfsan/libc_ubuntu2404_abilist.txt ================================================ fun:_Exit=uninstrumented fun:_Fork=uninstrumented fun:_IO_adjust_column=uninstrumented fun:_IO_adjust_wcolumn=uninstrumented fun:_IO_default_doallocate=uninstrumented fun:_IO_default_finish=uninstrumented fun:_IO_default_pbackfail=uninstrumented fun:_IO_default_uflow=uninstrumented fun:_IO_default_xsgetn=uninstrumented fun:_IO_default_xsputn=uninstrumented fun:_IO_do_write=uninstrumented fun:_IO_doallocbuf=uninstrumented fun:_IO_enable_locks=uninstrumented fun:_IO_fclose=uninstrumented fun:_IO_fdopen=uninstrumented fun:_IO_feof=uninstrumented fun:_IO_ferror=uninstrumented fun:_IO_fflush=uninstrumented fun:_IO_fgetpos=uninstrumented fun:_IO_fgetpos64=uninstrumented fun:_IO_fgets=uninstrumented fun:_IO_file_attach=uninstrumented fun:_IO_file_close=uninstrumented fun:_IO_file_close_it=uninstrumented fun:_IO_file_doallocate=uninstrumented fun:_IO_file_finish=uninstrumented fun:_IO_file_fopen=uninstrumented fun:_IO_file_init=uninstrumented fun:_IO_file_open=uninstrumented fun:_IO_file_overflow=uninstrumented fun:_IO_file_read=uninstrumented fun:_IO_file_seek=uninstrumented fun:_IO_file_seekoff=uninstrumented fun:_IO_file_setbuf=uninstrumented fun:_IO_file_stat=uninstrumented fun:_IO_file_sync=uninstrumented fun:_IO_file_underflow=uninstrumented fun:_IO_file_write=uninstrumented fun:_IO_file_xsputn=uninstrumented fun:_IO_flockfile=uninstrumented fun:_IO_flush_all=uninstrumented fun:_IO_flush_all_linebuffered=uninstrumented fun:_IO_fopen=uninstrumented fun:_IO_fprintf=uninstrumented fun:_IO_fputs=uninstrumented fun:_IO_fread=uninstrumented fun:_IO_free_backup_area=uninstrumented fun:_IO_free_wbackup_area=uninstrumented fun:_IO_fsetpos=uninstrumented fun:_IO_fsetpos64=uninstrumented fun:_IO_ftell=uninstrumented fun:_IO_ftrylockfile=uninstrumented fun:_IO_funlockfile=uninstrumented fun:_IO_fwrite=uninstrumented fun:_IO_getc=uninstrumented fun:_IO_getline=uninstrumented fun:_IO_getline_info=uninstrumented fun:_IO_gets=uninstrumented fun:_IO_init=uninstrumented fun:_IO_init_marker=uninstrumented fun:_IO_init_wmarker=uninstrumented fun:_IO_iter_begin=uninstrumented fun:_IO_iter_end=uninstrumented fun:_IO_iter_file=uninstrumented fun:_IO_iter_next=uninstrumented fun:_IO_least_wmarker=uninstrumented fun:_IO_link_in=uninstrumented fun:_IO_list_lock=uninstrumented fun:_IO_list_resetlock=uninstrumented fun:_IO_list_unlock=uninstrumented fun:_IO_marker_delta=uninstrumented fun:_IO_marker_difference=uninstrumented fun:_IO_padn=uninstrumented fun:_IO_peekc_locked=uninstrumented fun:_IO_popen=uninstrumented fun:_IO_printf=uninstrumented fun:_IO_proc_close=uninstrumented fun:_IO_proc_open=uninstrumented fun:_IO_putc=uninstrumented fun:_IO_puts=uninstrumented fun:_IO_remove_marker=uninstrumented fun:_IO_seekmark=uninstrumented fun:_IO_seekoff=uninstrumented fun:_IO_seekpos=uninstrumented fun:_IO_seekwmark=uninstrumented fun:_IO_setb=uninstrumented fun:_IO_setbuffer=uninstrumented fun:_IO_setvbuf=uninstrumented fun:_IO_sgetn=uninstrumented fun:_IO_sprintf=uninstrumented fun:_IO_sputbackc=uninstrumented fun:_IO_sputbackwc=uninstrumented fun:_IO_sscanf=uninstrumented fun:_IO_str_init_readonly=uninstrumented fun:_IO_str_init_static=uninstrumented fun:_IO_str_overflow=uninstrumented fun:_IO_str_pbackfail=uninstrumented fun:_IO_str_seekoff=uninstrumented fun:_IO_str_underflow=uninstrumented fun:_IO_sungetc=uninstrumented fun:_IO_sungetwc=uninstrumented fun:_IO_switch_to_get_mode=uninstrumented fun:_IO_switch_to_main_wget_area=uninstrumented fun:_IO_switch_to_wbackup_area=uninstrumented fun:_IO_switch_to_wget_mode=uninstrumented fun:_IO_un_link=uninstrumented fun:_IO_ungetc=uninstrumented fun:_IO_unsave_markers=uninstrumented fun:_IO_unsave_wmarkers=uninstrumented fun:_IO_vfprintf=uninstrumented fun:_IO_vfscanf=uninstrumented fun:_IO_vsprintf=uninstrumented fun:_IO_wdefault_doallocate=uninstrumented fun:_IO_wdefault_finish=uninstrumented fun:_IO_wdefault_pbackfail=uninstrumented fun:_IO_wdefault_uflow=uninstrumented fun:_IO_wdefault_xsgetn=uninstrumented fun:_IO_wdefault_xsputn=uninstrumented fun:_IO_wdo_write=uninstrumented fun:_IO_wdoallocbuf=uninstrumented fun:_IO_wfile_overflow=uninstrumented fun:_IO_wfile_seekoff=uninstrumented fun:_IO_wfile_sync=uninstrumented fun:_IO_wfile_underflow=uninstrumented fun:_IO_wfile_xsputn=uninstrumented fun:_IO_wmarker_delta=uninstrumented fun:_IO_wsetb=uninstrumented fun:_Unwind_Backtrace=uninstrumented fun:_Unwind_DeleteException=uninstrumented fun:_Unwind_FindEnclosingFunction=uninstrumented fun:_Unwind_Find_FDE=uninstrumented fun:_Unwind_ForcedUnwind=uninstrumented fun:_Unwind_GetCFA=uninstrumented fun:_Unwind_GetDataRelBase=uninstrumented fun:_Unwind_GetGR=uninstrumented fun:_Unwind_GetIP=uninstrumented fun:_Unwind_GetIPInfo=uninstrumented fun:_Unwind_GetLanguageSpecificData=uninstrumented fun:_Unwind_GetRegionStart=uninstrumented fun:_Unwind_GetTextRelBase=uninstrumented fun:_Unwind_RaiseException=uninstrumented fun:_Unwind_Resume=uninstrumented fun:_Unwind_Resume_or_Rethrow=uninstrumented fun:_Unwind_SetGR=uninstrumented fun:_Unwind_SetIP=uninstrumented fun:__absvdi2=uninstrumented fun:__absvsi2=uninstrumented fun:__absvti2=uninstrumented fun:__acos_finite=uninstrumented fun:__acosf128_finite=uninstrumented fun:__acosf_finite=uninstrumented fun:__acosh_finite=uninstrumented fun:__acoshf128_finite=uninstrumented fun:__acoshf_finite=uninstrumented fun:__acoshl_finite=uninstrumented fun:__acosl_finite=uninstrumented fun:__addtf3=uninstrumented fun:__addvdi3=uninstrumented fun:__addvsi3=uninstrumented fun:__addvti3=uninstrumented fun:__adjtimex=uninstrumented fun:__arch_prctl=uninstrumented fun:__argz_count=uninstrumented fun:__argz_next=uninstrumented fun:__argz_stringify=uninstrumented fun:__ashlti3=uninstrumented fun:__ashrti3=uninstrumented fun:__asin_finite=uninstrumented fun:__asinf128_finite=uninstrumented fun:__asinf_finite=uninstrumented fun:__asinl_finite=uninstrumented fun:__asprintf=uninstrumented fun:__asprintf_chk=uninstrumented fun:__assert=uninstrumented fun:__assert_fail=uninstrumented fun:__assert_perror_fail=uninstrumented fun:__atan2_finite=uninstrumented fun:__atan2f128_finite=uninstrumented fun:__atan2f_finite=uninstrumented fun:__atan2l_finite=uninstrumented fun:__atanh_finite=uninstrumented fun:__atanhf128_finite=uninstrumented fun:__atanhf_finite=uninstrumented fun:__atanhl_finite=uninstrumented fun:__avx_resms64_12=uninstrumented fun:__avx_resms64_13=uninstrumented fun:__avx_resms64_14=uninstrumented fun:__avx_resms64_15=uninstrumented fun:__avx_resms64_16=uninstrumented fun:__avx_resms64_17=uninstrumented fun:__avx_resms64_18=uninstrumented fun:__avx_resms64f_12=uninstrumented fun:__avx_resms64f_13=uninstrumented fun:__avx_resms64f_14=uninstrumented fun:__avx_resms64f_15=uninstrumented fun:__avx_resms64f_16=uninstrumented fun:__avx_resms64f_17=uninstrumented fun:__avx_resms64fx_12=uninstrumented fun:__avx_resms64fx_13=uninstrumented fun:__avx_resms64fx_14=uninstrumented fun:__avx_resms64fx_15=uninstrumented fun:__avx_resms64fx_16=uninstrumented fun:__avx_resms64fx_17=uninstrumented fun:__avx_resms64x_12=uninstrumented fun:__avx_resms64x_13=uninstrumented fun:__avx_resms64x_14=uninstrumented fun:__avx_resms64x_15=uninstrumented fun:__avx_resms64x_16=uninstrumented fun:__avx_resms64x_17=uninstrumented fun:__avx_resms64x_18=uninstrumented fun:__avx_savms64_12=uninstrumented fun:__avx_savms64_13=uninstrumented fun:__avx_savms64_14=uninstrumented fun:__avx_savms64_15=uninstrumented fun:__avx_savms64_16=uninstrumented fun:__avx_savms64_17=uninstrumented fun:__avx_savms64_18=uninstrumented fun:__avx_savms64f_12=uninstrumented fun:__avx_savms64f_13=uninstrumented fun:__avx_savms64f_14=uninstrumented fun:__avx_savms64f_15=uninstrumented fun:__avx_savms64f_16=uninstrumented fun:__avx_savms64f_17=uninstrumented fun:__b64_ntop=uninstrumented fun:__b64_pton=uninstrumented fun:__backtrace=uninstrumented fun:__backtrace_symbols=uninstrumented fun:__backtrace_symbols_fd=uninstrumented fun:__bid128_abs=uninstrumented fun:__bid128_add=uninstrumented fun:__bid128_class=uninstrumented fun:__bid128_copy=uninstrumented fun:__bid128_copySign=uninstrumented fun:__bid128_div=uninstrumented fun:__bid128_fma=uninstrumented fun:__bid128_from_int32=uninstrumented fun:__bid128_from_int64=uninstrumented fun:__bid128_from_uint32=uninstrumented fun:__bid128_from_uint64=uninstrumented fun:__bid128_isCanonical=uninstrumented fun:__bid128_isFinite=uninstrumented fun:__bid128_isInf=uninstrumented fun:__bid128_isNaN=uninstrumented fun:__bid128_isNormal=uninstrumented fun:__bid128_isSignaling=uninstrumented fun:__bid128_isSigned=uninstrumented fun:__bid128_isSubnormal=uninstrumented fun:__bid128_isZero=uninstrumented fun:__bid128_mul=uninstrumented fun:__bid128_negate=uninstrumented fun:__bid128_quiet_equal=uninstrumented fun:__bid128_quiet_greater=uninstrumented fun:__bid128_quiet_greater_equal=uninstrumented fun:__bid128_quiet_greater_unordered=uninstrumented fun:__bid128_quiet_less=uninstrumented fun:__bid128_quiet_less_equal=uninstrumented fun:__bid128_quiet_less_unordered=uninstrumented fun:__bid128_quiet_not_equal=uninstrumented fun:__bid128_quiet_not_greater=uninstrumented fun:__bid128_quiet_not_less=uninstrumented fun:__bid128_quiet_ordered=uninstrumented fun:__bid128_quiet_unordered=uninstrumented fun:__bid128_radix=uninstrumented fun:__bid128_sameQuantum=uninstrumented fun:__bid128_signaling_greater=uninstrumented fun:__bid128_signaling_greater_equal=uninstrumented fun:__bid128_signaling_greater_unordered=uninstrumented fun:__bid128_signaling_less=uninstrumented fun:__bid128_signaling_less_equal=uninstrumented fun:__bid128_signaling_less_unordered=uninstrumented fun:__bid128_signaling_not_greater=uninstrumented fun:__bid128_signaling_not_less=uninstrumented fun:__bid128_sub=uninstrumented fun:__bid128_to_bid32=uninstrumented fun:__bid128_to_bid64=uninstrumented fun:__bid128_to_binary128=uninstrumented fun:__bid128_to_binary32=uninstrumented fun:__bid128_to_binary64=uninstrumented fun:__bid128_to_binary80=uninstrumented fun:__bid128_to_int32_ceil=uninstrumented fun:__bid128_to_int32_floor=uninstrumented fun:__bid128_to_int32_int=uninstrumented fun:__bid128_to_int32_rnint=uninstrumented fun:__bid128_to_int32_rninta=uninstrumented fun:__bid128_to_int32_xceil=uninstrumented fun:__bid128_to_int32_xfloor=uninstrumented fun:__bid128_to_int32_xint=uninstrumented fun:__bid128_to_int32_xrnint=uninstrumented fun:__bid128_to_int32_xrninta=uninstrumented fun:__bid128_to_int64_ceil=uninstrumented fun:__bid128_to_int64_floor=uninstrumented fun:__bid128_to_int64_int=uninstrumented fun:__bid128_to_int64_rnint=uninstrumented fun:__bid128_to_int64_rninta=uninstrumented fun:__bid128_to_int64_xceil=uninstrumented fun:__bid128_to_int64_xfloor=uninstrumented fun:__bid128_to_int64_xint=uninstrumented fun:__bid128_to_int64_xrnint=uninstrumented fun:__bid128_to_int64_xrninta=uninstrumented fun:__bid128_to_uint32_ceil=uninstrumented fun:__bid128_to_uint32_floor=uninstrumented fun:__bid128_to_uint32_int=uninstrumented fun:__bid128_to_uint32_rnint=uninstrumented fun:__bid128_to_uint32_rninta=uninstrumented fun:__bid128_to_uint32_xceil=uninstrumented fun:__bid128_to_uint32_xfloor=uninstrumented fun:__bid128_to_uint32_xint=uninstrumented fun:__bid128_to_uint32_xrnint=uninstrumented fun:__bid128_to_uint32_xrninta=uninstrumented fun:__bid128_to_uint64_ceil=uninstrumented fun:__bid128_to_uint64_floor=uninstrumented fun:__bid128_to_uint64_int=uninstrumented fun:__bid128_to_uint64_rnint=uninstrumented fun:__bid128_to_uint64_rninta=uninstrumented fun:__bid128_to_uint64_xceil=uninstrumented fun:__bid128_to_uint64_xfloor=uninstrumented fun:__bid128_to_uint64_xint=uninstrumented fun:__bid128_to_uint64_xrnint=uninstrumented fun:__bid128_to_uint64_xrninta=uninstrumented fun:__bid128_totalOrder=uninstrumented fun:__bid128_totalOrderMag=uninstrumented fun:__bid128dd_add=uninstrumented fun:__bid128dd_div=uninstrumented fun:__bid128dd_mul=uninstrumented fun:__bid128dd_sub=uninstrumented fun:__bid128ddd_fma=uninstrumented fun:__bid128ddq_fma=uninstrumented fun:__bid128dq_add=uninstrumented fun:__bid128dq_div=uninstrumented fun:__bid128dq_mul=uninstrumented fun:__bid128dq_sub=uninstrumented fun:__bid128dqd_fma=uninstrumented fun:__bid128dqq_fma=uninstrumented fun:__bid128qd_add=uninstrumented fun:__bid128qd_div=uninstrumented fun:__bid128qd_mul=uninstrumented fun:__bid128qd_sub=uninstrumented fun:__bid128qdd_fma=uninstrumented fun:__bid128qdq_fma=uninstrumented fun:__bid128qqd_fma=uninstrumented fun:__bid32_to_bid128=uninstrumented fun:__bid32_to_bid64=uninstrumented fun:__bid32_to_binary128=uninstrumented fun:__bid32_to_binary32=uninstrumented fun:__bid32_to_binary64=uninstrumented fun:__bid32_to_binary80=uninstrumented fun:__bid64_abs=uninstrumented fun:__bid64_add=uninstrumented fun:__bid64_class=uninstrumented fun:__bid64_copy=uninstrumented fun:__bid64_copySign=uninstrumented fun:__bid64_div=uninstrumented fun:__bid64_from_int32=uninstrumented fun:__bid64_from_int64=uninstrumented fun:__bid64_from_uint32=uninstrumented fun:__bid64_from_uint64=uninstrumented fun:__bid64_isCanonical=uninstrumented fun:__bid64_isFinite=uninstrumented fun:__bid64_isInf=uninstrumented fun:__bid64_isNaN=uninstrumented fun:__bid64_isNormal=uninstrumented fun:__bid64_isSignaling=uninstrumented fun:__bid64_isSigned=uninstrumented fun:__bid64_isSubnormal=uninstrumented fun:__bid64_isZero=uninstrumented fun:__bid64_mul=uninstrumented fun:__bid64_negate=uninstrumented fun:__bid64_quiet_equal=uninstrumented fun:__bid64_quiet_greater=uninstrumented fun:__bid64_quiet_greater_equal=uninstrumented fun:__bid64_quiet_greater_unordered=uninstrumented fun:__bid64_quiet_less=uninstrumented fun:__bid64_quiet_less_equal=uninstrumented fun:__bid64_quiet_less_unordered=uninstrumented fun:__bid64_quiet_not_equal=uninstrumented fun:__bid64_quiet_not_greater=uninstrumented fun:__bid64_quiet_not_less=uninstrumented fun:__bid64_quiet_ordered=uninstrumented fun:__bid64_quiet_unordered=uninstrumented fun:__bid64_radix=uninstrumented fun:__bid64_sameQuantum=uninstrumented fun:__bid64_signaling_greater=uninstrumented fun:__bid64_signaling_greater_equal=uninstrumented fun:__bid64_signaling_greater_unordered=uninstrumented fun:__bid64_signaling_less=uninstrumented fun:__bid64_signaling_less_equal=uninstrumented fun:__bid64_signaling_less_unordered=uninstrumented fun:__bid64_signaling_not_greater=uninstrumented fun:__bid64_signaling_not_less=uninstrumented fun:__bid64_sub=uninstrumented fun:__bid64_to_bid128=uninstrumented fun:__bid64_to_bid32=uninstrumented fun:__bid64_to_binary128=uninstrumented fun:__bid64_to_binary32=uninstrumented fun:__bid64_to_binary64=uninstrumented fun:__bid64_to_binary80=uninstrumented fun:__bid64_to_int32_ceil=uninstrumented fun:__bid64_to_int32_floor=uninstrumented fun:__bid64_to_int32_int=uninstrumented fun:__bid64_to_int32_rnint=uninstrumented fun:__bid64_to_int32_rninta=uninstrumented fun:__bid64_to_int32_xceil=uninstrumented fun:__bid64_to_int32_xfloor=uninstrumented fun:__bid64_to_int32_xint=uninstrumented fun:__bid64_to_int32_xrnint=uninstrumented fun:__bid64_to_int32_xrninta=uninstrumented fun:__bid64_to_int64_ceil=uninstrumented fun:__bid64_to_int64_floor=uninstrumented fun:__bid64_to_int64_int=uninstrumented fun:__bid64_to_int64_rnint=uninstrumented fun:__bid64_to_int64_rninta=uninstrumented fun:__bid64_to_int64_xceil=uninstrumented fun:__bid64_to_int64_xfloor=uninstrumented fun:__bid64_to_int64_xint=uninstrumented fun:__bid64_to_int64_xrnint=uninstrumented fun:__bid64_to_int64_xrninta=uninstrumented fun:__bid64_to_uint32_ceil=uninstrumented fun:__bid64_to_uint32_floor=uninstrumented fun:__bid64_to_uint32_int=uninstrumented fun:__bid64_to_uint32_rnint=uninstrumented fun:__bid64_to_uint32_rninta=uninstrumented fun:__bid64_to_uint32_xceil=uninstrumented fun:__bid64_to_uint32_xfloor=uninstrumented fun:__bid64_to_uint32_xint=uninstrumented fun:__bid64_to_uint32_xrnint=uninstrumented fun:__bid64_to_uint32_xrninta=uninstrumented fun:__bid64_to_uint64_ceil=uninstrumented fun:__bid64_to_uint64_floor=uninstrumented fun:__bid64_to_uint64_int=uninstrumented fun:__bid64_to_uint64_rnint=uninstrumented fun:__bid64_to_uint64_rninta=uninstrumented fun:__bid64_to_uint64_xceil=uninstrumented fun:__bid64_to_uint64_xfloor=uninstrumented fun:__bid64_to_uint64_xint=uninstrumented fun:__bid64_to_uint64_xrnint=uninstrumented fun:__bid64_to_uint64_xrninta=uninstrumented fun:__bid64_totalOrder=uninstrumented fun:__bid64_totalOrderMag=uninstrumented fun:__bid64ddq_fma=uninstrumented fun:__bid64dq_add=uninstrumented fun:__bid64dq_div=uninstrumented fun:__bid64dq_mul=uninstrumented fun:__bid64dq_sub=uninstrumented fun:__bid64dqd_fma=uninstrumented fun:__bid64dqq_fma=uninstrumented fun:__bid64qd_add=uninstrumented fun:__bid64qd_div=uninstrumented fun:__bid64qd_mul=uninstrumented fun:__bid64qd_sub=uninstrumented fun:__bid64qdd_fma=uninstrumented fun:__bid64qdq_fma=uninstrumented fun:__bid64qq_add=uninstrumented fun:__bid64qq_div=uninstrumented fun:__bid64qq_mul=uninstrumented fun:__bid64qq_sub=uninstrumented fun:__bid64qqd_fma=uninstrumented fun:__bid64qqq_fma=uninstrumented fun:__bid_adddd3=uninstrumented fun:__bid_addsd3=uninstrumented fun:__bid_addtd3=uninstrumented fun:__bid_divdd3=uninstrumented fun:__bid_divsd3=uninstrumented fun:__bid_divtd3=uninstrumented fun:__bid_eqdd2=uninstrumented fun:__bid_eqsd2=uninstrumented fun:__bid_eqtd2=uninstrumented fun:__bid_extendddtd2=uninstrumented fun:__bid_extendddtf=uninstrumented fun:__bid_extendddxf=uninstrumented fun:__bid_extenddfdd=uninstrumented fun:__bid_extenddftd=uninstrumented fun:__bid_extendsddd2=uninstrumented fun:__bid_extendsddf=uninstrumented fun:__bid_extendsdtd2=uninstrumented fun:__bid_extendsdtf=uninstrumented fun:__bid_extendsdxf=uninstrumented fun:__bid_extendsfdd=uninstrumented fun:__bid_extendsfsd=uninstrumented fun:__bid_extendsftd=uninstrumented fun:__bid_extendtftd=uninstrumented fun:__bid_extendxftd=uninstrumented fun:__bid_fixdddi=uninstrumented fun:__bid_fixddsi=uninstrumented fun:__bid_fixsddi=uninstrumented fun:__bid_fixsdsi=uninstrumented fun:__bid_fixtddi=uninstrumented fun:__bid_fixtdsi=uninstrumented fun:__bid_fixunsdddi=uninstrumented fun:__bid_fixunsddsi=uninstrumented fun:__bid_fixunssddi=uninstrumented fun:__bid_fixunssdsi=uninstrumented fun:__bid_fixunstddi=uninstrumented fun:__bid_fixunstdsi=uninstrumented fun:__bid_floatdidd=uninstrumented fun:__bid_floatdisd=uninstrumented fun:__bid_floatditd=uninstrumented fun:__bid_floatsidd=uninstrumented fun:__bid_floatsisd=uninstrumented fun:__bid_floatsitd=uninstrumented fun:__bid_floatunsdidd=uninstrumented fun:__bid_floatunsdisd=uninstrumented fun:__bid_floatunsditd=uninstrumented fun:__bid_floatunssidd=uninstrumented fun:__bid_floatunssisd=uninstrumented fun:__bid_floatunssitd=uninstrumented fun:__bid_gedd2=uninstrumented fun:__bid_gesd2=uninstrumented fun:__bid_getd2=uninstrumented fun:__bid_gtdd2=uninstrumented fun:__bid_gtsd2=uninstrumented fun:__bid_gttd2=uninstrumented fun:__bid_ledd2=uninstrumented fun:__bid_lesd2=uninstrumented fun:__bid_letd2=uninstrumented fun:__bid_ltdd2=uninstrumented fun:__bid_ltsd2=uninstrumented fun:__bid_lttd2=uninstrumented fun:__bid_muldd3=uninstrumented fun:__bid_mulsd3=uninstrumented fun:__bid_multd3=uninstrumented fun:__bid_nedd2=uninstrumented fun:__bid_nesd2=uninstrumented fun:__bid_netd2=uninstrumented fun:__bid_round128_19_38=uninstrumented fun:__bid_round192_39_57=uninstrumented fun:__bid_round256_58_76=uninstrumented fun:__bid_round64_2_18=uninstrumented fun:__bid_subdd3=uninstrumented fun:__bid_subsd3=uninstrumented fun:__bid_subtd3=uninstrumented fun:__bid_truncdddf=uninstrumented fun:__bid_truncddsd2=uninstrumented fun:__bid_truncddsf=uninstrumented fun:__bid_truncdfsd=uninstrumented fun:__bid_truncsdsf=uninstrumented fun:__bid_trunctddd2=uninstrumented fun:__bid_trunctddf=uninstrumented fun:__bid_trunctdsd2=uninstrumented fun:__bid_trunctdsf=uninstrumented fun:__bid_trunctdtf=uninstrumented fun:__bid_trunctdxf=uninstrumented fun:__bid_trunctfdd=uninstrumented fun:__bid_trunctfsd=uninstrumented fun:__bid_truncxfdd=uninstrumented fun:__bid_truncxfsd=uninstrumented fun:__bid_unorddd2=uninstrumented fun:__bid_unordsd2=uninstrumented fun:__bid_unordtd2=uninstrumented fun:__binary128_to_bid128=uninstrumented fun:__binary128_to_bid32=uninstrumented fun:__binary128_to_bid64=uninstrumented fun:__binary32_to_bid128=uninstrumented fun:__binary32_to_bid32=uninstrumented fun:__binary32_to_bid64=uninstrumented fun:__binary64_to_bid128=uninstrumented fun:__binary64_to_bid32=uninstrumented fun:__binary64_to_bid64=uninstrumented fun:__binary80_to_bid128=uninstrumented fun:__binary80_to_bid32=uninstrumented fun:__binary80_to_bid64=uninstrumented fun:__bsd_getpgrp=uninstrumented fun:__bswapdi2=uninstrumented fun:__bswapsi2=uninstrumented fun:__bzero=uninstrumented fun:__call_tls_dtors=uninstrumented fun:__chk_fail=uninstrumented fun:__clear_cache=uninstrumented fun:__clock_gettime=uninstrumented fun:__clog10=uninstrumented fun:__clog10f=uninstrumented fun:__clog10l=uninstrumented fun:__clone=uninstrumented fun:__close=uninstrumented fun:__close_nocancel=uninstrumented fun:__clrsbdi2=uninstrumented fun:__clrsbti2=uninstrumented fun:__clzdi2=uninstrumented fun:__clzti2=uninstrumented fun:__cmpti2=uninstrumented fun:__cmsg_nxthdr=uninstrumented fun:__confstr_chk=uninstrumented fun:__connect=uninstrumented fun:__copy_grp=uninstrumented fun:__cosh_finite=uninstrumented fun:__coshf128_finite=uninstrumented fun:__coshf_finite=uninstrumented fun:__coshl_finite=uninstrumented fun:__cpu_indicator_init=uninstrumented fun:__create_ib_request=uninstrumented fun:__ctype_b_loc=uninstrumented fun:__ctype_get_mb_cur_max=uninstrumented fun:__ctype_init=uninstrumented fun:__ctype_tolower_loc=uninstrumented fun:__ctype_toupper_loc=uninstrumented fun:__ctzdi2=uninstrumented fun:__ctzti2=uninstrumented fun:__cxa_at_quick_exit=uninstrumented fun:__cxa_atexit=uninstrumented fun:__cxa_finalize=uninstrumented fun:__cxa_thread_atexit_impl=uninstrumented fun:__cyg_profile_func_enter=uninstrumented fun:__cyg_profile_func_exit=uninstrumented fun:__dcgettext=uninstrumented fun:__default_morecore=uninstrumented fun:__deregister_frame=uninstrumented fun:__deregister_frame_info=uninstrumented fun:__deregister_frame_info_bases=uninstrumented fun:__dfp_clear_except=uninstrumented fun:__dfp_get_round=uninstrumented fun:__dfp_raise_except=uninstrumented fun:__dfp_set_round=uninstrumented fun:__dfp_test_except=uninstrumented fun:__dgettext=uninstrumented fun:__divdc3=uninstrumented fun:__divhc3=uninstrumented fun:__divmodbitint4=uninstrumented fun:__divmodti4=uninstrumented fun:__divsc3=uninstrumented fun:__divtc3=uninstrumented fun:__divtf3=uninstrumented fun:__divti3=uninstrumented fun:__divxc3=uninstrumented fun:__dn_comp=uninstrumented fun:__dn_count_labels=uninstrumented fun:__dn_expand=uninstrumented fun:__dn_skipname=uninstrumented fun:__do_niscall3=uninstrumented fun:__dprintf_chk=uninstrumented fun:__dup2=uninstrumented fun:__duplocale=uninstrumented fun:__emutls_get_address=uninstrumented fun:__emutls_register_common=uninstrumented fun:__enable_execute_stack=uninstrumented fun:__endmntent=uninstrumented fun:__eprintf=uninstrumented fun:__eqhf2=uninstrumented fun:__eqtf2=uninstrumented fun:__errno_location=uninstrumented fun:__exp10_finite=uninstrumented fun:__exp10f128_finite=uninstrumented fun:__exp10f_finite=uninstrumented fun:__exp10l_finite=uninstrumented fun:__exp2_finite=uninstrumented fun:__exp2f128_finite=uninstrumented fun:__exp2f_finite=uninstrumented fun:__exp2l_finite=uninstrumented fun:__exp_finite=uninstrumented fun:__expf128_finite=uninstrumented fun:__expf_finite=uninstrumented fun:__expl_finite=uninstrumented fun:__explicit_bzero_chk=uninstrumented fun:__extendbfsf2=uninstrumented fun:__extenddftf2=uninstrumented fun:__extendhfdf2=uninstrumented fun:__extendhfsf2=uninstrumented fun:__extendhftf2=uninstrumented fun:__extendhfxf2=uninstrumented fun:__extendsfdf2=uninstrumented fun:__extendsftf2=uninstrumented fun:__extendxftf2=uninstrumented fun:__fbufsize=uninstrumented fun:__fcntl=uninstrumented fun:__fdelt_chk=uninstrumented fun:__fdelt_warn=uninstrumented fun:__fentry__=uninstrumented fun:__ffs=uninstrumented fun:__ffsdi2=uninstrumented fun:__ffsti2=uninstrumented fun:__fgets_chk=uninstrumented fun:__fgets_unlocked_chk=uninstrumented fun:__fgetws_chk=uninstrumented fun:__fgetws_unlocked_chk=uninstrumented fun:__file_change_detection_for_fp=uninstrumented fun:__file_change_detection_for_path=uninstrumented fun:__file_change_detection_for_stat=uninstrumented fun:__file_is_unchanged=uninstrumented fun:__finite=uninstrumented fun:__finitef=uninstrumented fun:__finitef128=uninstrumented fun:__finitel=uninstrumented fun:__fixdfbitint=uninstrumented fun:__fixdfti=uninstrumented fun:__fixhfti=uninstrumented fun:__fixsfbitint=uninstrumented fun:__fixsfti=uninstrumented fun:__fixtfbitint=uninstrumented fun:__fixtfdi=uninstrumented fun:__fixtfsi=uninstrumented fun:__fixtfti=uninstrumented fun:__fixunsdfdi=uninstrumented fun:__fixunsdfti=uninstrumented fun:__fixunshfti=uninstrumented fun:__fixunssfdi=uninstrumented fun:__fixunssfti=uninstrumented fun:__fixunstfdi=uninstrumented fun:__fixunstfsi=uninstrumented fun:__fixunstfti=uninstrumented fun:__fixunsxfdi=uninstrumented fun:__fixunsxfti=uninstrumented fun:__fixxfbitint=uninstrumented fun:__fixxfti=uninstrumented fun:__flbf=uninstrumented fun:__floatbitintbf=uninstrumented fun:__floatbitintdf=uninstrumented fun:__floatbitinthf=uninstrumented fun:__floatbitintsf=uninstrumented fun:__floatbitinttf=uninstrumented fun:__floatbitintxf=uninstrumented fun:__floatditf=uninstrumented fun:__floatsitf=uninstrumented fun:__floattibf=uninstrumented fun:__floattidf=uninstrumented fun:__floattihf=uninstrumented fun:__floattisf=uninstrumented fun:__floattitf=uninstrumented fun:__floattixf=uninstrumented fun:__floatunditf=uninstrumented fun:__floatunsitf=uninstrumented fun:__floatuntibf=uninstrumented fun:__floatuntidf=uninstrumented fun:__floatuntihf=uninstrumented fun:__floatuntisf=uninstrumented fun:__floatuntitf=uninstrumented fun:__floatuntixf=uninstrumented fun:__fmod_finite=uninstrumented fun:__fmodf128_finite=uninstrumented fun:__fmodf_finite=uninstrumented fun:__fmodl_finite=uninstrumented fun:__follow_path=uninstrumented fun:__fork=uninstrumented fun:__fortify_fail=uninstrumented fun:__fp_nquery=uninstrumented fun:__fp_query=uninstrumented fun:__fp_resstat=uninstrumented fun:__fpclassify=uninstrumented fun:__fpclassifyf=uninstrumented fun:__fpclassifyf128=uninstrumented fun:__fpclassifyl=uninstrumented fun:__fpending=uninstrumented fun:__fprintf_chk=uninstrumented fun:__fpurge=uninstrumented fun:__fread_chk=uninstrumented fun:__fread_unlocked_chk=uninstrumented fun:__freadable=uninstrumented fun:__freading=uninstrumented fun:__free_fdresult=uninstrumented fun:__freelocale=uninstrumented fun:__fseeko64=uninstrumented fun:__fsetlocking=uninstrumented fun:__fstat64=uninstrumented fun:__ftello64=uninstrumented fun:__fwprintf_chk=uninstrumented fun:__fwritable=uninstrumented fun:__fwriting=uninstrumented fun:__fxstat=uninstrumented fun:__fxstat64=uninstrumented fun:__fxstatat=uninstrumented fun:__fxstatat64=uninstrumented fun:__gamma_r_finite=uninstrumented fun:__gammaf128_r_finite=uninstrumented fun:__gammaf_r_finite=uninstrumented fun:__gammal_r_finite=uninstrumented fun:__gcc_bcmp=uninstrumented fun:__gcc_nested_func_ptr_created=uninstrumented fun:__gcc_nested_func_ptr_deleted=uninstrumented fun:__gcc_personality_v0=uninstrumented fun:__gconv_create_spec=uninstrumented fun:__gconv_destroy_spec=uninstrumented fun:__gconv_get_alias_db=uninstrumented fun:__gconv_get_cache=uninstrumented fun:__gconv_get_modules_db=uninstrumented fun:__gconv_open=uninstrumented fun:__gconv_transliterate=uninstrumented fun:__generic_findstack=uninstrumented fun:__generic_morestack=uninstrumented fun:__generic_morestack_set_initial_sp=uninstrumented fun:__generic_releasestack=uninstrumented fun:__getauxval=uninstrumented fun:__getcwd_chk=uninstrumented fun:__getdelim=uninstrumented fun:__getdomainname_chk=uninstrumented fun:__getf2=uninstrumented fun:__getgroups_chk=uninstrumented fun:__gethostname_chk=uninstrumented fun:__getlogin_r_chk=uninstrumented fun:__getmntent_r=uninstrumented fun:__getpagesize=uninstrumented fun:__getpgid=uninstrumented fun:__getpid=uninstrumented fun:__getrlimit=uninstrumented fun:__gets_chk=uninstrumented fun:__gettimeofday=uninstrumented fun:__getwd_chk=uninstrumented fun:__gmtime_r=uninstrumented fun:__gttf2=uninstrumented fun:__h_errno_location=uninstrumented fun:__hardcfr_check=uninstrumented fun:__hostalias=uninstrumented fun:__hypot_finite=uninstrumented fun:__hypotf128_finite=uninstrumented fun:__hypotf_finite=uninstrumented fun:__hypotl_finite=uninstrumented fun:__idna_from_dns_encoding=uninstrumented fun:__idna_to_dns_encoding=uninstrumented fun:__inet6_scopeid_pton=uninstrumented fun:__inet_aton_exact=uninstrumented fun:__inet_pton_length=uninstrumented fun:__internal_endnetgrent=uninstrumented fun:__internal_getnetgrent_r=uninstrumented fun:__internal_setnetgrent=uninstrumented fun:__isalnum_l=uninstrumented fun:__isalpha_l=uninstrumented fun:__isascii_l=uninstrumented fun:__isblank_l=uninstrumented fun:__iscanonicall=uninstrumented fun:__iscntrl_l=uninstrumented fun:__isctype=uninstrumented fun:__isdigit_l=uninstrumented fun:__iseqsig=uninstrumented fun:__iseqsigf=uninstrumented fun:__iseqsigf128=uninstrumented fun:__iseqsigl=uninstrumented fun:__isgraph_l=uninstrumented fun:__isinf=uninstrumented fun:__isinff=uninstrumented fun:__isinff128=uninstrumented fun:__isinfl=uninstrumented fun:__islower_l=uninstrumented fun:__isnan=uninstrumented fun:__isnanf=uninstrumented fun:__isnanf128=uninstrumented fun:__isnanl=uninstrumented fun:__isoc23_fscanf=uninstrumented fun:__isoc23_fwscanf=uninstrumented fun:__isoc23_scanf=uninstrumented fun:__isoc23_sscanf=uninstrumented fun:__isoc23_strtoimax=uninstrumented fun:__isoc23_strtol=uninstrumented fun:__isoc23_strtol_l=uninstrumented fun:__isoc23_strtoll=uninstrumented fun:__isoc23_strtoll_l=uninstrumented fun:__isoc23_strtoul=uninstrumented fun:__isoc23_strtoul_l=uninstrumented fun:__isoc23_strtoull=uninstrumented fun:__isoc23_strtoull_l=uninstrumented fun:__isoc23_strtoumax=uninstrumented fun:__isoc23_swscanf=uninstrumented fun:__isoc23_vfscanf=uninstrumented fun:__isoc23_vfwscanf=uninstrumented fun:__isoc23_vscanf=uninstrumented fun:__isoc23_vsscanf=uninstrumented fun:__isoc23_vswscanf=uninstrumented fun:__isoc23_vwscanf=uninstrumented fun:__isoc23_wcstoimax=uninstrumented fun:__isoc23_wcstol=uninstrumented fun:__isoc23_wcstol_l=uninstrumented fun:__isoc23_wcstoll=uninstrumented fun:__isoc23_wcstoll_l=uninstrumented fun:__isoc23_wcstoul=uninstrumented fun:__isoc23_wcstoul_l=uninstrumented fun:__isoc23_wcstoull=uninstrumented fun:__isoc23_wcstoull_l=uninstrumented fun:__isoc23_wcstoumax=uninstrumented fun:__isoc23_wscanf=uninstrumented fun:__isoc99_fscanf=uninstrumented fun:__isoc99_fwscanf=uninstrumented fun:__isoc99_scanf=uninstrumented fun:__isoc99_sscanf=uninstrumented fun:__isoc99_swscanf=uninstrumented fun:__isoc99_vfscanf=uninstrumented fun:__isoc99_vfwscanf=uninstrumented fun:__isoc99_vscanf=uninstrumented fun:__isoc99_vsscanf=uninstrumented fun:__isoc99_vswscanf=uninstrumented fun:__isoc99_vwscanf=uninstrumented fun:__isoc99_wscanf=uninstrumented fun:__isprint_l=uninstrumented fun:__ispunct_l=uninstrumented fun:__issignaling=uninstrumented fun:__issignalingf=uninstrumented fun:__issignalingf128=uninstrumented fun:__issignalingl=uninstrumented fun:__isspace_l=uninstrumented fun:__isupper_l=uninstrumented fun:__iswalnum_l=uninstrumented fun:__iswalpha_l=uninstrumented fun:__iswblank_l=uninstrumented fun:__iswcntrl_l=uninstrumented fun:__iswctype=uninstrumented fun:__iswctype_l=uninstrumented fun:__iswdigit_l=uninstrumented fun:__iswgraph_l=uninstrumented fun:__iswlower_l=uninstrumented fun:__iswprint_l=uninstrumented fun:__iswpunct_l=uninstrumented fun:__iswspace_l=uninstrumented fun:__iswupper_l=uninstrumented fun:__iswxdigit_l=uninstrumented fun:__isxdigit_l=uninstrumented fun:__ivaliduser=uninstrumented fun:__j0_finite=uninstrumented fun:__j0f128_finite=uninstrumented fun:__j0f_finite=uninstrumented fun:__j0l_finite=uninstrumented fun:__j1_finite=uninstrumented fun:__j1f128_finite=uninstrumented fun:__j1f_finite=uninstrumented fun:__j1l_finite=uninstrumented fun:__jn_finite=uninstrumented fun:__jnf128_finite=uninstrumented fun:__jnf_finite=uninstrumented fun:__jnl_finite=uninstrumented fun:__letf2=uninstrumented fun:__lgamma_r_finite=uninstrumented fun:__lgammaf128_r_finite=uninstrumented fun:__lgammaf_r_finite=uninstrumented fun:__lgammal_r_finite=uninstrumented fun:__libanl_version_placeholder=uninstrumented fun:__libc_alloc_buffer_alloc_array=uninstrumented fun:__libc_alloc_buffer_allocate=uninstrumented fun:__libc_alloc_buffer_copy_bytes=uninstrumented fun:__libc_alloc_buffer_copy_string=uninstrumented fun:__libc_alloc_buffer_create_failure=uninstrumented fun:__libc_alloca_cutoff=uninstrumented fun:__libc_allocate_once_slow=uninstrumented fun:__libc_allocate_rtsig=uninstrumented fun:__libc_calloc=uninstrumented fun:__libc_clntudp_bufcreate=uninstrumented fun:__libc_current_sigrtmax=uninstrumented fun:__libc_current_sigrtmin=uninstrumented fun:__libc_dn_expand=uninstrumented fun:__libc_dn_skipname=uninstrumented fun:__libc_dynarray_at_failure=uninstrumented fun:__libc_dynarray_emplace_enlarge=uninstrumented fun:__libc_dynarray_finalize=uninstrumented fun:__libc_dynarray_resize=uninstrumented fun:__libc_dynarray_resize_clear=uninstrumented fun:__libc_early_init=uninstrumented fun:__libc_fatal=uninstrumented fun:__libc_fcntl64=uninstrumented fun:__libc_fork=uninstrumented fun:__libc_free=uninstrumented fun:__libc_freeres=uninstrumented fun:__libc_ifunc_impl_list=uninstrumented fun:__libc_init_first=uninstrumented fun:__libc_mallinfo=uninstrumented fun:__libc_malloc=uninstrumented fun:__libc_mallopt=uninstrumented fun:__libc_memalign=uninstrumented fun:__libc_msgrcv=uninstrumented fun:__libc_msgsnd=uninstrumented fun:__libc_ns_makecanon=uninstrumented fun:__libc_ns_samename=uninstrumented fun:__libc_pread=uninstrumented fun:__libc_pvalloc=uninstrumented fun:__libc_pwrite=uninstrumented fun:__libc_realloc=uninstrumented fun:__libc_reallocarray=uninstrumented fun:__libc_res_dnok=uninstrumented fun:__libc_res_hnok=uninstrumented fun:__libc_res_nameinquery=uninstrumented fun:__libc_res_queriesmatch=uninstrumented fun:__libc_rpc_getport=uninstrumented fun:__libc_sa_len=uninstrumented fun:__libc_scratch_buffer_grow=uninstrumented fun:__libc_scratch_buffer_grow_preserve=uninstrumented fun:__libc_scratch_buffer_set_array_size=uninstrumented fun:__libc_secure_getenv=uninstrumented fun:__libc_sigaction=uninstrumented fun:__libc_start_main=uninstrumented fun:__libc_system=uninstrumented fun:__libc_unwind_link_get=uninstrumented fun:__libc_valloc=uninstrumented fun:__libdl_version_placeholder=uninstrumented fun:__libpthread_version_placeholder=uninstrumented fun:__librt_version_placeholder=uninstrumented fun:__libutil_version_placeholder=uninstrumented fun:__lll_lock_wait_private=uninstrumented fun:__lll_lock_wake_private=uninstrumented fun:__loc_aton=uninstrumented fun:__loc_ntoa=uninstrumented fun:__log10_finite=uninstrumented fun:__log10f128_finite=uninstrumented fun:__log10f_finite=uninstrumented fun:__log10l_finite=uninstrumented fun:__log2_finite=uninstrumented fun:__log2f128_finite=uninstrumented fun:__log2f_finite=uninstrumented fun:__log2l_finite=uninstrumented fun:__log_finite=uninstrumented fun:__logf128_finite=uninstrumented fun:__logf_finite=uninstrumented fun:__logl_finite=uninstrumented fun:__longjmp_chk=uninstrumented fun:__lseek=uninstrumented fun:__lshrti3=uninstrumented fun:__lttf2=uninstrumented fun:__lxstat=uninstrumented fun:__lxstat64=uninstrumented fun:__madvise=uninstrumented fun:__mbrlen=uninstrumented fun:__mbrtowc=uninstrumented fun:__mbsnrtowcs_chk=uninstrumented fun:__mbsrtowcs_chk=uninstrumented fun:__mbstowcs_chk=uninstrumented fun:__memcmpeq=uninstrumented fun:__memcpy_chk=uninstrumented fun:__memmove_chk=uninstrumented fun:__mempcpy=uninstrumented fun:__mempcpy_chk=uninstrumented fun:__mempcpy_small=uninstrumented fun:__memset_chk=uninstrumented fun:__merge_grp=uninstrumented fun:__mktemp=uninstrumented fun:__mmap=uninstrumented fun:__modti3=uninstrumented fun:__monstartup=uninstrumented fun:__morestack=uninstrumented fun:__morestack_allocate_stack_space=uninstrumented fun:__morestack_block_signals=uninstrumented fun:__morestack_fail=uninstrumented fun:__morestack_get_guard=uninstrumented fun:__morestack_large_model=uninstrumented fun:__morestack_load_mmap=uninstrumented fun:__morestack_make_guard=uninstrumented fun:__morestack_non_split=uninstrumented fun:__morestack_release_segments=uninstrumented fun:__morestack_set_guard=uninstrumented fun:__morestack_unblock_signals=uninstrumented fun:__mprotect=uninstrumented fun:__mq_open_2=uninstrumented fun:__mulbitint3=uninstrumented fun:__muldc3=uninstrumented fun:__mulhc3=uninstrumented fun:__mulsc3=uninstrumented fun:__multc3=uninstrumented fun:__multf3=uninstrumented fun:__multi3=uninstrumented fun:__mulvdi3=uninstrumented fun:__mulvsi3=uninstrumented fun:__mulvti3=uninstrumented fun:__mulxc3=uninstrumented fun:__munmap=uninstrumented fun:__nanosleep=uninstrumented fun:__negtf2=uninstrumented fun:__negti2=uninstrumented fun:__negvdi2=uninstrumented fun:__negvsi2=uninstrumented fun:__negvti2=uninstrumented fun:__nehf2=uninstrumented fun:__netf2=uninstrumented fun:__netlink_assert_response=uninstrumented fun:__newlocale=uninstrumented fun:__nis_default_access=uninstrumented fun:__nis_default_group=uninstrumented fun:__nis_default_owner=uninstrumented fun:__nis_default_ttl=uninstrumented fun:__nis_finddirectory=uninstrumented fun:__nis_hash=uninstrumented fun:__nisbind_connect=uninstrumented fun:__nisbind_create=uninstrumented fun:__nisbind_destroy=uninstrumented fun:__nisbind_next=uninstrumented fun:__nl_langinfo_l=uninstrumented fun:__nptl_change_stack_perm=uninstrumented fun:__nptl_create_event=uninstrumented fun:__nptl_death_event=uninstrumented fun:__ns_get16=uninstrumented fun:__ns_get32=uninstrumented fun:__ns_name_compress=uninstrumented fun:__ns_name_ntop=uninstrumented fun:__ns_name_pack=uninstrumented fun:__ns_name_pton=uninstrumented fun:__ns_name_skip=uninstrumented fun:__ns_name_uncompress=uninstrumented fun:__ns_name_unpack=uninstrumented fun:__nss_configure_lookup=uninstrumented fun:__nss_database_get=uninstrumented fun:__nss_database_lookup=uninstrumented fun:__nss_disable_nscd=uninstrumented fun:__nss_files_data_endent=uninstrumented fun:__nss_files_data_open=uninstrumented fun:__nss_files_data_put=uninstrumented fun:__nss_files_data_setent=uninstrumented fun:__nss_files_fopen=uninstrumented fun:__nss_group_lookup=uninstrumented fun:__nss_group_lookup2=uninstrumented fun:__nss_hash=uninstrumented fun:__nss_hostname_digits_dots=uninstrumented fun:__nss_hosts_lookup=uninstrumented fun:__nss_hosts_lookup2=uninstrumented fun:__nss_lookup=uninstrumented fun:__nss_lookup_function=uninstrumented fun:__nss_next=uninstrumented fun:__nss_next2=uninstrumented fun:__nss_parse_line_result=uninstrumented fun:__nss_passwd_lookup=uninstrumented fun:__nss_passwd_lookup2=uninstrumented fun:__nss_readline=uninstrumented fun:__nss_services_lookup2=uninstrumented fun:__obstack_printf_chk=uninstrumented fun:__obstack_vprintf_chk=uninstrumented fun:__open=uninstrumented fun:__open64=uninstrumented fun:__open64_2=uninstrumented fun:__open64_nocancel=uninstrumented fun:__open_2=uninstrumented fun:__open_catalog=uninstrumented fun:__open_nocancel=uninstrumented fun:__openat64_2=uninstrumented fun:__openat_2=uninstrumented fun:__overflow=uninstrumented fun:__p_cdname=uninstrumented fun:__p_cdnname=uninstrumented fun:__p_class=uninstrumented fun:__p_fqname=uninstrumented fun:__p_fqnname=uninstrumented fun:__p_option=uninstrumented fun:__p_query=uninstrumented fun:__p_rcode=uninstrumented fun:__p_secstodate=uninstrumented fun:__p_time=uninstrumented fun:__p_type=uninstrumented fun:__paritydi2=uninstrumented fun:__parityti2=uninstrumented fun:__pipe=uninstrumented fun:__poll=uninstrumented fun:__poll_chk=uninstrumented fun:__popcountdi2=uninstrumented fun:__popcountti2=uninstrumented fun:__posix_getopt=uninstrumented fun:__pow_finite=uninstrumented fun:__powf128_finite=uninstrumented fun:__powf_finite=uninstrumented fun:__powidf2=uninstrumented fun:__powisf2=uninstrumented fun:__powitf2=uninstrumented fun:__powixf2=uninstrumented fun:__powl_finite=uninstrumented fun:__ppoll_chk=uninstrumented fun:__pread64=uninstrumented fun:__pread64_chk=uninstrumented fun:__pread64_nocancel=uninstrumented fun:__pread_chk=uninstrumented fun:__prepare_niscall=uninstrumented fun:__printf_chk=uninstrumented fun:__printf_fp=uninstrumented fun:__profile_frequency=uninstrumented fun:__pthread_atfork=uninstrumented fun:__pthread_cleanup_routine=uninstrumented fun:__pthread_get_minstack=uninstrumented fun:__pthread_getspecific=uninstrumented fun:__pthread_key_create=uninstrumented fun:__pthread_mutex_destroy=uninstrumented fun:__pthread_mutex_init=uninstrumented fun:__pthread_mutex_lock=uninstrumented fun:__pthread_mutex_trylock=uninstrumented fun:__pthread_mutex_unlock=uninstrumented fun:__pthread_mutexattr_destroy=uninstrumented fun:__pthread_mutexattr_init=uninstrumented fun:__pthread_mutexattr_settype=uninstrumented fun:__pthread_once=uninstrumented fun:__pthread_register_cancel=uninstrumented fun:__pthread_register_cancel_defer=uninstrumented fun:__pthread_rwlock_destroy=uninstrumented fun:__pthread_rwlock_init=uninstrumented fun:__pthread_rwlock_rdlock=uninstrumented fun:__pthread_rwlock_tryrdlock=uninstrumented fun:__pthread_rwlock_trywrlock=uninstrumented fun:__pthread_rwlock_unlock=uninstrumented fun:__pthread_rwlock_wrlock=uninstrumented fun:__pthread_setspecific=uninstrumented fun:__pthread_unregister_cancel=uninstrumented fun:__pthread_unregister_cancel_restore=uninstrumented fun:__pthread_unwind_next=uninstrumented fun:__ptsname_r_chk=uninstrumented fun:__putlong=uninstrumented fun:__putshort=uninstrumented fun:__pwrite64=uninstrumented fun:__rawmemchr=uninstrumented fun:__read=uninstrumented fun:__read_chk=uninstrumented fun:__read_nocancel=uninstrumented fun:__readlink_chk=uninstrumented fun:__readlinkat_chk=uninstrumented fun:__realpath_chk=uninstrumented fun:__recv=uninstrumented fun:__recv_chk=uninstrumented fun:__recvfrom_chk=uninstrumented fun:__register_atfork=uninstrumented fun:__register_frame=uninstrumented fun:__register_frame_info=uninstrumented fun:__register_frame_info_bases=uninstrumented fun:__register_frame_info_table=uninstrumented fun:__register_frame_info_table_bases=uninstrumented fun:__register_frame_table=uninstrumented fun:__remainder_finite=uninstrumented fun:__remainderf128_finite=uninstrumented fun:__remainderf_finite=uninstrumented fun:__remainderl_finite=uninstrumented fun:__res_close=uninstrumented fun:__res_context_hostalias=uninstrumented fun:__res_context_mkquery=uninstrumented fun:__res_context_query=uninstrumented fun:__res_context_search=uninstrumented fun:__res_context_send=uninstrumented fun:__res_dnok=uninstrumented fun:__res_get_nsaddr=uninstrumented fun:__res_hnok=uninstrumented fun:__res_hostalias=uninstrumented fun:__res_iclose=uninstrumented fun:__res_init=uninstrumented fun:__res_isourserver=uninstrumented fun:__res_mailok=uninstrumented fun:__res_mkquery=uninstrumented fun:__res_nameinquery=uninstrumented fun:__res_nclose=uninstrumented fun:__res_ninit=uninstrumented fun:__res_nmkquery=uninstrumented fun:__res_nopt=uninstrumented fun:__res_nquery=uninstrumented fun:__res_nquerydomain=uninstrumented fun:__res_nsearch=uninstrumented fun:__res_nsend=uninstrumented fun:__res_ownok=uninstrumented fun:__res_queriesmatch=uninstrumented fun:__res_query=uninstrumented fun:__res_querydomain=uninstrumented fun:__res_randomid=uninstrumented fun:__res_search=uninstrumented fun:__res_send=uninstrumented fun:__res_state=uninstrumented fun:__resolv_context_get=uninstrumented fun:__resolv_context_get_override=uninstrumented fun:__resolv_context_get_preinit=uninstrumented fun:__resolv_context_put=uninstrumented fun:__rpc_thread_createerr=uninstrumented fun:__rpc_thread_svc_fdset=uninstrumented fun:__rpc_thread_svc_max_pollfd=uninstrumented fun:__rpc_thread_svc_pollfd=uninstrumented fun:__rtld_version_placeholder=uninstrumented fun:__sbrk=uninstrumented fun:__scalb_finite=uninstrumented fun:__scalbf_finite=uninstrumented fun:__scalbl_finite=uninstrumented fun:__sched_cpualloc=uninstrumented fun:__sched_cpucount=uninstrumented fun:__sched_cpufree=uninstrumented fun:__sched_get_priority_max=uninstrumented fun:__sched_get_priority_min=uninstrumented fun:__sched_getparam=uninstrumented fun:__sched_getscheduler=uninstrumented fun:__sched_setscheduler=uninstrumented fun:__sched_yield=uninstrumented fun:__secure_getenv=uninstrumented fun:__select=uninstrumented fun:__send=uninstrumented fun:__sendmmsg=uninstrumented fun:__setmntent=uninstrumented fun:__setpgid=uninstrumented fun:__sfp_handle_exceptions=uninstrumented fun:__shm_get_name=uninstrumented fun:__sigaction=uninstrumented fun:__sigaddset=uninstrumented fun:__sigdelset=uninstrumented fun:__sigismember=uninstrumented fun:__signbit=uninstrumented fun:__signbitf=uninstrumented fun:__signbitf128=uninstrumented fun:__signbitl=uninstrumented fun:__sigpause=uninstrumented fun:__sigsetjmp=uninstrumented fun:__sigsuspend=uninstrumented fun:__sigtimedwait=uninstrumented fun:__sinh_finite=uninstrumented fun:__sinhf128_finite=uninstrumented fun:__sinhf_finite=uninstrumented fun:__sinhl_finite=uninstrumented fun:__snprintf_chk=uninstrumented fun:__socket=uninstrumented fun:__splitstack_block_signals=uninstrumented fun:__splitstack_block_signals_context=uninstrumented fun:__splitstack_find=uninstrumented fun:__splitstack_find_context=uninstrumented fun:__splitstack_getcontext=uninstrumented fun:__splitstack_makecontext=uninstrumented fun:__splitstack_releasecontext=uninstrumented fun:__splitstack_resetcontext=uninstrumented fun:__splitstack_setcontext=uninstrumented fun:__sprintf_chk=uninstrumented fun:__sqrt_finite=uninstrumented fun:__sqrtf128_finite=uninstrumented fun:__sqrtf_finite=uninstrumented fun:__sqrtl_finite=uninstrumented fun:__sse_resms64_12=uninstrumented fun:__sse_resms64_13=uninstrumented fun:__sse_resms64_14=uninstrumented fun:__sse_resms64_15=uninstrumented fun:__sse_resms64_16=uninstrumented fun:__sse_resms64_17=uninstrumented fun:__sse_resms64_18=uninstrumented fun:__sse_resms64f_12=uninstrumented fun:__sse_resms64f_13=uninstrumented fun:__sse_resms64f_14=uninstrumented fun:__sse_resms64f_15=uninstrumented fun:__sse_resms64f_16=uninstrumented fun:__sse_resms64f_17=uninstrumented fun:__sse_resms64fx_12=uninstrumented fun:__sse_resms64fx_13=uninstrumented fun:__sse_resms64fx_14=uninstrumented fun:__sse_resms64fx_15=uninstrumented fun:__sse_resms64fx_16=uninstrumented fun:__sse_resms64fx_17=uninstrumented fun:__sse_resms64x_12=uninstrumented fun:__sse_resms64x_13=uninstrumented fun:__sse_resms64x_14=uninstrumented fun:__sse_resms64x_15=uninstrumented fun:__sse_resms64x_16=uninstrumented fun:__sse_resms64x_17=uninstrumented fun:__sse_resms64x_18=uninstrumented fun:__sse_savms64_12=uninstrumented fun:__sse_savms64_13=uninstrumented fun:__sse_savms64_14=uninstrumented fun:__sse_savms64_15=uninstrumented fun:__sse_savms64_16=uninstrumented fun:__sse_savms64_17=uninstrumented fun:__sse_savms64_18=uninstrumented fun:__sse_savms64f_12=uninstrumented fun:__sse_savms64f_13=uninstrumented fun:__sse_savms64f_14=uninstrumented fun:__sse_savms64f_15=uninstrumented fun:__sse_savms64f_16=uninstrumented fun:__sse_savms64f_17=uninstrumented fun:__stack_chk_fail=uninstrumented fun:__stack_chk_fail_local=uninstrumented fun:__stack_split_initialize=uninstrumented fun:__statfs=uninstrumented fun:__stpcpy=uninstrumented fun:__stpcpy_chk=uninstrumented fun:__stpcpy_small=uninstrumented fun:__stpncpy=uninstrumented fun:__stpncpy_chk=uninstrumented fun:__strcasecmp=uninstrumented fun:__strcasecmp_l=uninstrumented fun:__strcasestr=uninstrumented fun:__strcat_chk=uninstrumented fun:__strcoll_l=uninstrumented fun:__strcpy_chk=uninstrumented fun:__strcpy_small=uninstrumented fun:__strcspn_c1=uninstrumented fun:__strcspn_c2=uninstrumented fun:__strcspn_c3=uninstrumented fun:__strdup=uninstrumented fun:__strerror_r=uninstrumented fun:__strfmon_l=uninstrumented fun:__strftime_l=uninstrumented fun:__strlcat_chk=uninstrumented fun:__strlcpy_chk=uninstrumented fun:__strncasecmp_l=uninstrumented fun:__strncat_chk=uninstrumented fun:__strncpy_chk=uninstrumented fun:__strndup=uninstrumented fun:__strpbrk_c2=uninstrumented fun:__strpbrk_c3=uninstrumented fun:__strsep_1c=uninstrumented fun:__strsep_2c=uninstrumented fun:__strsep_3c=uninstrumented fun:__strsep_g=uninstrumented fun:__strspn_c1=uninstrumented fun:__strspn_c2=uninstrumented fun:__strspn_c3=uninstrumented fun:__strtod_internal=uninstrumented fun:__strtod_l=uninstrumented fun:__strtod_nan=uninstrumented fun:__strtof128_internal=uninstrumented fun:__strtof128_nan=uninstrumented fun:__strtof_internal=uninstrumented fun:__strtof_l=uninstrumented fun:__strtof_nan=uninstrumented fun:__strtok_r=uninstrumented fun:__strtok_r_1c=uninstrumented fun:__strtol_internal=uninstrumented fun:__strtol_l=uninstrumented fun:__strtold_internal=uninstrumented fun:__strtold_l=uninstrumented fun:__strtold_nan=uninstrumented fun:__strtoll_internal=uninstrumented fun:__strtoll_l=uninstrumented fun:__strtoul_internal=uninstrumented fun:__strtoul_l=uninstrumented fun:__strtoull_internal=uninstrumented fun:__strtoull_l=uninstrumented fun:__strub_enter=uninstrumented fun:__strub_leave=uninstrumented fun:__strub_update=uninstrumented fun:__strverscmp=uninstrumented fun:__strxfrm_l=uninstrumented fun:__subtf3=uninstrumented fun:__subvdi3=uninstrumented fun:__subvsi3=uninstrumented fun:__subvti3=uninstrumented fun:__swprintf_chk=uninstrumented fun:__sym_ntop=uninstrumented fun:__sym_ntos=uninstrumented fun:__sym_ston=uninstrumented fun:__sysconf=uninstrumented fun:__sysctl=uninstrumented fun:__syslog_chk=uninstrumented fun:__sysv_signal=uninstrumented fun:__tdelete=uninstrumented fun:__tfind=uninstrumented fun:__tls_get_addr=uninstrumented fun:__toascii_l=uninstrumented fun:__tolower_l=uninstrumented fun:__toupper_l=uninstrumented fun:__towctrans=uninstrumented fun:__towctrans_l=uninstrumented fun:__towlower_l=uninstrumented fun:__towupper_l=uninstrumented fun:__truncdfbf2=uninstrumented fun:__truncdfhf2=uninstrumented fun:__truncdfsf2=uninstrumented fun:__trunchfbf2=uninstrumented fun:__truncsfbf2=uninstrumented fun:__truncsfhf2=uninstrumented fun:__trunctfbf2=uninstrumented fun:__trunctfdf2=uninstrumented fun:__trunctfhf2=uninstrumented fun:__trunctfsf2=uninstrumented fun:__trunctfxf2=uninstrumented fun:__truncxfbf2=uninstrumented fun:__truncxfhf2=uninstrumented fun:__tsearch=uninstrumented fun:__ttyname_r_chk=uninstrumented fun:__tunable_get_val=uninstrumented fun:__tunable_is_initialized=uninstrumented fun:__twalk=uninstrumented fun:__twalk_r=uninstrumented fun:__ucmpti2=uninstrumented fun:__udiv_w_sdiv=uninstrumented fun:__udivmodti4=uninstrumented fun:__udivti3=uninstrumented fun:__uflow=uninstrumented fun:__umodti3=uninstrumented fun:__underflow=uninstrumented fun:__unordtf2=uninstrumented fun:__uselocale=uninstrumented fun:__vasprintf_chk=uninstrumented fun:__vdprintf_chk=uninstrumented fun:__vfork=uninstrumented fun:__vfprintf_chk=uninstrumented fun:__vfscanf=uninstrumented fun:__vfwprintf_chk=uninstrumented fun:__vprintf_chk=uninstrumented fun:__vsnprintf=uninstrumented fun:__vsnprintf_chk=uninstrumented fun:__vsprintf_chk=uninstrumented fun:__vsscanf=uninstrumented fun:__vswprintf_chk=uninstrumented fun:__vsyslog_chk=uninstrumented fun:__vwprintf_chk=uninstrumented fun:__wait=uninstrumented fun:__waitpid=uninstrumented fun:__wcpcpy_chk=uninstrumented fun:__wcpncpy_chk=uninstrumented fun:__wcrtomb_chk=uninstrumented fun:__wcscasecmp_l=uninstrumented fun:__wcscat_chk=uninstrumented fun:__wcscoll_l=uninstrumented fun:__wcscpy_chk=uninstrumented fun:__wcsftime_l=uninstrumented fun:__wcslcat_chk=uninstrumented fun:__wcslcpy_chk=uninstrumented fun:__wcsncasecmp_l=uninstrumented fun:__wcsncat_chk=uninstrumented fun:__wcsncpy_chk=uninstrumented fun:__wcsnrtombs_chk=uninstrumented fun:__wcsrtombs_chk=uninstrumented fun:__wcstod_internal=uninstrumented fun:__wcstod_l=uninstrumented fun:__wcstof128_internal=uninstrumented fun:__wcstof_internal=uninstrumented fun:__wcstof_l=uninstrumented fun:__wcstol_internal=uninstrumented fun:__wcstol_l=uninstrumented fun:__wcstold_internal=uninstrumented fun:__wcstold_l=uninstrumented fun:__wcstoll_internal=uninstrumented fun:__wcstoll_l=uninstrumented fun:__wcstombs_chk=uninstrumented fun:__wcstoul_internal=uninstrumented fun:__wcstoul_l=uninstrumented fun:__wcstoull_internal=uninstrumented fun:__wcstoull_l=uninstrumented fun:__wcsxfrm_l=uninstrumented fun:__wctomb_chk=uninstrumented fun:__wctrans_l=uninstrumented fun:__wctype_l=uninstrumented fun:__wmemcpy_chk=uninstrumented fun:__wmemmove_chk=uninstrumented fun:__wmempcpy_chk=uninstrumented fun:__wmemset_chk=uninstrumented fun:__woverflow=uninstrumented fun:__wprintf_chk=uninstrumented fun:__wrap_pthread_create=uninstrumented fun:__write=uninstrumented fun:__write_nocancel=uninstrumented fun:__wuflow=uninstrumented fun:__wunderflow=uninstrumented fun:__x86_get_cpuid_feature_leaf=uninstrumented fun:__xmknod=uninstrumented fun:__xmknodat=uninstrumented fun:__xpg_basename=uninstrumented fun:__xpg_sigpause=uninstrumented fun:__xpg_strerror_r=uninstrumented fun:__xstat=uninstrumented fun:__xstat64=uninstrumented fun:__y0_finite=uninstrumented fun:__y0f128_finite=uninstrumented fun:__y0f_finite=uninstrumented fun:__y0l_finite=uninstrumented fun:__y1_finite=uninstrumented fun:__y1f128_finite=uninstrumented fun:__y1f_finite=uninstrumented fun:__y1l_finite=uninstrumented fun:__yn_finite=uninstrumented fun:__ynf128_finite=uninstrumented fun:__ynf_finite=uninstrumented fun:__ynl_finite=uninstrumented fun:__yp_check=uninstrumented fun:_authenticate=uninstrumented fun:_dl_allocate_tls=uninstrumented fun:_dl_allocate_tls_init=uninstrumented fun:_dl_audit_preinit=uninstrumented fun:_dl_audit_symbind_alt=uninstrumented fun:_dl_catch_exception=uninstrumented fun:_dl_deallocate_tls=uninstrumented fun:_dl_debug_state=uninstrumented fun:_dl_exception_create=uninstrumented fun:_dl_exception_create_format=uninstrumented fun:_dl_exception_free=uninstrumented fun:_dl_fatal_printf=uninstrumented fun:_dl_find_dso_for_object=uninstrumented fun:_dl_find_object=uninstrumented fun:_dl_get_tls_static_info=uninstrumented fun:_dl_mcount=uninstrumented fun:_dl_mcount_wrapper=uninstrumented fun:_dl_mcount_wrapper_check=uninstrumented fun:_dl_rtld_di_serinfo=uninstrumented fun:_dl_signal_error=uninstrumented fun:_dl_signal_exception=uninstrumented fun:_dl_x86_get_cpu_features=uninstrumented fun:_exit=uninstrumented fun:_flushlbf=uninstrumented fun:_gethtbyaddr=uninstrumented fun:_gethtbyname=uninstrumented fun:_gethtbyname2=uninstrumented fun:_gethtent=uninstrumented fun:_getlong=uninstrumented fun:_getshort=uninstrumented fun:_longjmp=uninstrumented fun:_mcleanup=uninstrumented fun:_mcount=uninstrumented fun:_nss_dns_getcanonname_r=uninstrumented fun:_nss_dns_gethostbyaddr2_r=uninstrumented fun:_nss_dns_gethostbyaddr_r=uninstrumented fun:_nss_dns_gethostbyname2_r=uninstrumented fun:_nss_dns_gethostbyname3_r=uninstrumented fun:_nss_dns_gethostbyname4_r=uninstrumented fun:_nss_dns_gethostbyname_r=uninstrumented fun:_nss_dns_getnetbyaddr_r=uninstrumented fun:_nss_dns_getnetbyname_r=uninstrumented fun:_nss_files_endaliasent=uninstrumented fun:_nss_files_endetherent=uninstrumented fun:_nss_files_endgrent=uninstrumented fun:_nss_files_endhostent=uninstrumented fun:_nss_files_endnetent=uninstrumented fun:_nss_files_endnetgrent=uninstrumented fun:_nss_files_endprotoent=uninstrumented fun:_nss_files_endpwent=uninstrumented fun:_nss_files_endrpcent=uninstrumented fun:_nss_files_endservent=uninstrumented fun:_nss_files_endsgent=uninstrumented fun:_nss_files_endspent=uninstrumented fun:_nss_files_getaliasbyname_r=uninstrumented fun:_nss_files_getaliasent_r=uninstrumented fun:_nss_files_getetherent_r=uninstrumented fun:_nss_files_getgrent_r=uninstrumented fun:_nss_files_getgrgid_r=uninstrumented fun:_nss_files_getgrnam_r=uninstrumented fun:_nss_files_gethostbyaddr_r=uninstrumented fun:_nss_files_gethostbyname2_r=uninstrumented fun:_nss_files_gethostbyname3_r=uninstrumented fun:_nss_files_gethostbyname4_r=uninstrumented fun:_nss_files_gethostbyname_r=uninstrumented fun:_nss_files_gethostent_r=uninstrumented fun:_nss_files_gethostton_r=uninstrumented fun:_nss_files_getnetbyaddr_r=uninstrumented fun:_nss_files_getnetbyname_r=uninstrumented fun:_nss_files_getnetent_r=uninstrumented fun:_nss_files_getnetgrent_r=uninstrumented fun:_nss_files_getntohost_r=uninstrumented fun:_nss_files_getprotobyname_r=uninstrumented fun:_nss_files_getprotobynumber_r=uninstrumented fun:_nss_files_getprotoent_r=uninstrumented fun:_nss_files_getpwent_r=uninstrumented fun:_nss_files_getpwnam_r=uninstrumented fun:_nss_files_getpwuid_r=uninstrumented fun:_nss_files_getrpcbyname_r=uninstrumented fun:_nss_files_getrpcbynumber_r=uninstrumented fun:_nss_files_getrpcent_r=uninstrumented fun:_nss_files_getservbyname_r=uninstrumented fun:_nss_files_getservbyport_r=uninstrumented fun:_nss_files_getservent_r=uninstrumented fun:_nss_files_getsgent_r=uninstrumented fun:_nss_files_getsgnam_r=uninstrumented fun:_nss_files_getspent_r=uninstrumented fun:_nss_files_getspnam_r=uninstrumented fun:_nss_files_init=uninstrumented fun:_nss_files_initgroups_dyn=uninstrumented fun:_nss_files_parse_etherent=uninstrumented fun:_nss_files_parse_grent=uninstrumented fun:_nss_files_parse_netent=uninstrumented fun:_nss_files_parse_protoent=uninstrumented fun:_nss_files_parse_pwent=uninstrumented fun:_nss_files_parse_rpcent=uninstrumented fun:_nss_files_parse_servent=uninstrumented fun:_nss_files_parse_sgent=uninstrumented fun:_nss_files_parse_spent=uninstrumented fun:_nss_files_setaliasent=uninstrumented fun:_nss_files_setetherent=uninstrumented fun:_nss_files_setgrent=uninstrumented fun:_nss_files_sethostent=uninstrumented fun:_nss_files_setnetent=uninstrumented fun:_nss_files_setnetgrent=uninstrumented fun:_nss_files_setprotoent=uninstrumented fun:_nss_files_setpwent=uninstrumented fun:_nss_files_setrpcent=uninstrumented fun:_nss_files_setservent=uninstrumented fun:_nss_files_setsgent=uninstrumented fun:_nss_files_setspent=uninstrumented fun:_nss_netgroup_parseline=uninstrumented fun:_obstack_allocated_p=uninstrumented fun:_obstack_begin=uninstrumented fun:_obstack_begin_1=uninstrumented fun:_obstack_free=uninstrumented fun:_obstack_memory_used=uninstrumented fun:_obstack_newchunk=uninstrumented fun:_pthread_cleanup_pop=uninstrumented fun:_pthread_cleanup_pop_restore=uninstrumented fun:_pthread_cleanup_push=uninstrumented fun:_pthread_cleanup_push_defer=uninstrumented fun:_rpc_dtablesize=uninstrumented fun:_seterr_reply=uninstrumented fun:_sethtent=uninstrumented fun:_setjmp=uninstrumented fun:_tolower=uninstrumented fun:_toupper=uninstrumented fun:_xdr_ib_request=uninstrumented fun:_xdr_nis_result=uninstrumented fun:a64l=uninstrumented fun:abort=uninstrumented fun:abs=uninstrumented fun:accept=uninstrumented fun:accept4=uninstrumented fun:access=uninstrumented fun:acct=uninstrumented fun:acos=uninstrumented fun:acosf=uninstrumented fun:acosf128=uninstrumented fun:acosf32=uninstrumented fun:acosf32x=uninstrumented fun:acosf64=uninstrumented fun:acosf64x=uninstrumented fun:acosh=uninstrumented fun:acoshf=uninstrumented fun:acoshf128=uninstrumented fun:acoshf32=uninstrumented fun:acoshf32x=uninstrumented fun:acoshf64=uninstrumented fun:acoshf64x=uninstrumented fun:acoshl=uninstrumented fun:acosl=uninstrumented fun:addmntent=uninstrumented fun:addseverity=uninstrumented fun:adjtime=uninstrumented fun:adjtimex=uninstrumented fun:advance=uninstrumented fun:aio_cancel=uninstrumented fun:aio_cancel64=uninstrumented fun:aio_error=uninstrumented fun:aio_error64=uninstrumented fun:aio_fsync=uninstrumented fun:aio_fsync64=uninstrumented fun:aio_init=uninstrumented fun:aio_read=uninstrumented fun:aio_read64=uninstrumented fun:aio_return=uninstrumented fun:aio_return64=uninstrumented fun:aio_suspend=uninstrumented fun:aio_suspend64=uninstrumented fun:aio_write=uninstrumented fun:aio_write64=uninstrumented fun:alarm=uninstrumented fun:aligned_alloc=uninstrumented fun:alphasort=uninstrumented fun:alphasort64=uninstrumented fun:arc4random=uninstrumented fun:arc4random_buf=uninstrumented fun:arc4random_uniform=uninstrumented fun:arch_prctl=uninstrumented fun:argp_error=uninstrumented fun:argp_failure=uninstrumented fun:argp_help=uninstrumented fun:argp_parse=uninstrumented fun:argp_state_help=uninstrumented fun:argp_usage=uninstrumented fun:argz_add=uninstrumented fun:argz_add_sep=uninstrumented fun:argz_append=uninstrumented fun:argz_count=uninstrumented fun:argz_create=uninstrumented fun:argz_create_sep=uninstrumented fun:argz_delete=uninstrumented fun:argz_extract=uninstrumented fun:argz_insert=uninstrumented fun:argz_next=uninstrumented fun:argz_replace=uninstrumented fun:argz_stringify=uninstrumented fun:asctime=uninstrumented fun:asctime_r=uninstrumented fun:asin=uninstrumented fun:asinf=uninstrumented fun:asinf128=uninstrumented fun:asinf32=uninstrumented fun:asinf32x=uninstrumented fun:asinf64=uninstrumented fun:asinf64x=uninstrumented fun:asinh=uninstrumented fun:asinhf=uninstrumented fun:asinhf128=uninstrumented fun:asinhf32=uninstrumented fun:asinhf32x=uninstrumented fun:asinhf64=uninstrumented fun:asinhf64x=uninstrumented fun:asinhl=uninstrumented fun:asinl=uninstrumented fun:asprintf=uninstrumented fun:at_quick_exit=uninstrumented fun:atan=uninstrumented fun:atan2=uninstrumented fun:atan2f=uninstrumented fun:atan2f128=uninstrumented fun:atan2f32=uninstrumented fun:atan2f32x=uninstrumented fun:atan2f64=uninstrumented fun:atan2f64x=uninstrumented fun:atan2l=uninstrumented fun:atanf=uninstrumented fun:atanf128=uninstrumented fun:atanf32=uninstrumented fun:atanf32x=uninstrumented fun:atanf64=uninstrumented fun:atanf64x=uninstrumented fun:atanh=uninstrumented fun:atanhf=uninstrumented fun:atanhf128=uninstrumented fun:atanhf32=uninstrumented fun:atanhf32x=uninstrumented fun:atanhf64=uninstrumented fun:atanhf64x=uninstrumented fun:atanhl=uninstrumented fun:atanl=uninstrumented fun:atexit=uninstrumented fun:atof=uninstrumented fun:atoi=uninstrumented fun:atol=uninstrumented fun:atoll=uninstrumented fun:authdes_create=uninstrumented fun:authdes_getucred=uninstrumented fun:authdes_pk_create=uninstrumented fun:authnone_create=uninstrumented fun:authunix_create=uninstrumented fun:authunix_create_default=uninstrumented fun:backtrace=uninstrumented fun:backtrace_symbols=uninstrumented fun:backtrace_symbols_fd=uninstrumented fun:basename=uninstrumented fun:bcmp=uninstrumented fun:bcopy=uninstrumented fun:bdflush=uninstrumented fun:bind=uninstrumented fun:bind_textdomain_codeset=uninstrumented fun:bindresvport=uninstrumented fun:bindtextdomain=uninstrumented fun:brk=uninstrumented fun:bsd_signal=uninstrumented fun:bsearch=uninstrumented fun:btowc=uninstrumented fun:bzero=uninstrumented fun:c16rtomb=uninstrumented fun:c32rtomb=uninstrumented fun:c8rtomb=uninstrumented fun:cabs=uninstrumented fun:cabsf=uninstrumented fun:cabsf128=uninstrumented fun:cabsf32=uninstrumented fun:cabsf32x=uninstrumented fun:cabsf64=uninstrumented fun:cabsf64x=uninstrumented fun:cabsl=uninstrumented fun:cacos=uninstrumented fun:cacosf=uninstrumented fun:cacosf128=uninstrumented fun:cacosf32=uninstrumented fun:cacosf32x=uninstrumented fun:cacosf64=uninstrumented fun:cacosf64x=uninstrumented fun:cacosh=uninstrumented fun:cacoshf=uninstrumented fun:cacoshf128=uninstrumented fun:cacoshf32=uninstrumented fun:cacoshf32x=uninstrumented fun:cacoshf64=uninstrumented fun:cacoshf64x=uninstrumented fun:cacoshl=uninstrumented fun:cacosl=uninstrumented fun:call_once=uninstrumented fun:calloc=uninstrumented fun:callrpc=uninstrumented fun:canonicalize=uninstrumented fun:canonicalize_file_name=uninstrumented fun:canonicalizef=uninstrumented fun:canonicalizef128=uninstrumented fun:canonicalizef32=uninstrumented fun:canonicalizef32x=uninstrumented fun:canonicalizef64=uninstrumented fun:canonicalizef64x=uninstrumented fun:canonicalizel=uninstrumented fun:capget=uninstrumented fun:capset=uninstrumented fun:carg=uninstrumented fun:cargf=uninstrumented fun:cargf128=uninstrumented fun:cargf32=uninstrumented fun:cargf32x=uninstrumented fun:cargf64=uninstrumented fun:cargf64x=uninstrumented fun:cargl=uninstrumented fun:casin=uninstrumented fun:casinf=uninstrumented fun:casinf128=uninstrumented fun:casinf32=uninstrumented fun:casinf32x=uninstrumented fun:casinf64=uninstrumented fun:casinf64x=uninstrumented fun:casinh=uninstrumented fun:casinhf=uninstrumented fun:casinhf128=uninstrumented fun:casinhf32=uninstrumented fun:casinhf32x=uninstrumented fun:casinhf64=uninstrumented fun:casinhf64x=uninstrumented fun:casinhl=uninstrumented fun:casinl=uninstrumented fun:catan=uninstrumented fun:catanf=uninstrumented fun:catanf128=uninstrumented fun:catanf32=uninstrumented fun:catanf32x=uninstrumented fun:catanf64=uninstrumented fun:catanf64x=uninstrumented fun:catanh=uninstrumented fun:catanhf=uninstrumented fun:catanhf128=uninstrumented fun:catanhf32=uninstrumented fun:catanhf32x=uninstrumented fun:catanhf64=uninstrumented fun:catanhf64x=uninstrumented fun:catanhl=uninstrumented fun:catanl=uninstrumented fun:catclose=uninstrumented fun:catgets=uninstrumented fun:catopen=uninstrumented fun:cbc_crypt=uninstrumented fun:cbrt=uninstrumented fun:cbrtf=uninstrumented fun:cbrtf128=uninstrumented fun:cbrtf32=uninstrumented fun:cbrtf32x=uninstrumented fun:cbrtf64=uninstrumented fun:cbrtf64x=uninstrumented fun:cbrtl=uninstrumented fun:ccos=uninstrumented fun:ccosf=uninstrumented fun:ccosf128=uninstrumented fun:ccosf32=uninstrumented fun:ccosf32x=uninstrumented fun:ccosf64=uninstrumented fun:ccosf64x=uninstrumented fun:ccosh=uninstrumented fun:ccoshf=uninstrumented fun:ccoshf128=uninstrumented fun:ccoshf32=uninstrumented fun:ccoshf32x=uninstrumented fun:ccoshf64=uninstrumented fun:ccoshf64x=uninstrumented fun:ccoshl=uninstrumented fun:ccosl=uninstrumented fun:ceil=uninstrumented fun:ceilf=uninstrumented fun:ceilf128=uninstrumented fun:ceilf32=uninstrumented fun:ceilf32x=uninstrumented fun:ceilf64=uninstrumented fun:ceilf64x=uninstrumented fun:ceill=uninstrumented fun:cexp=uninstrumented fun:cexpf=uninstrumented fun:cexpf128=uninstrumented fun:cexpf32=uninstrumented fun:cexpf32x=uninstrumented fun:cexpf64=uninstrumented fun:cexpf64x=uninstrumented fun:cexpl=uninstrumented fun:cfgetispeed=uninstrumented fun:cfgetospeed=uninstrumented fun:cfmakeraw=uninstrumented fun:cfree=uninstrumented fun:cfsetispeed=uninstrumented fun:cfsetospeed=uninstrumented fun:cfsetspeed=uninstrumented fun:chdir=uninstrumented fun:chflags=uninstrumented fun:chmod=uninstrumented fun:chown=uninstrumented fun:chroot=uninstrumented fun:cimag=uninstrumented fun:cimagf=uninstrumented fun:cimagf128=uninstrumented fun:cimagf32=uninstrumented fun:cimagf32x=uninstrumented fun:cimagf64=uninstrumented fun:cimagf64x=uninstrumented fun:cimagl=uninstrumented fun:clearenv=uninstrumented fun:clearerr=uninstrumented fun:clearerr_unlocked=uninstrumented fun:clnt_broadcast=uninstrumented fun:clnt_create=uninstrumented fun:clnt_pcreateerror=uninstrumented fun:clnt_perrno=uninstrumented fun:clnt_perror=uninstrumented fun:clnt_spcreateerror=uninstrumented fun:clnt_sperrno=uninstrumented fun:clnt_sperror=uninstrumented fun:clntraw_create=uninstrumented fun:clnttcp_create=uninstrumented fun:clntudp_bufcreate=uninstrumented fun:clntudp_create=uninstrumented fun:clntunix_create=uninstrumented fun:clock=uninstrumented fun:clock_adjtime=uninstrumented fun:clock_getcpuclockid=uninstrumented fun:clock_getres=uninstrumented fun:clock_gettime=uninstrumented fun:clock_nanosleep=uninstrumented fun:clock_settime=uninstrumented fun:clog=uninstrumented fun:clog10=uninstrumented fun:clog10f=uninstrumented fun:clog10f128=uninstrumented fun:clog10f32=uninstrumented fun:clog10f32x=uninstrumented fun:clog10f64=uninstrumented fun:clog10f64x=uninstrumented fun:clog10l=uninstrumented fun:clogf=uninstrumented fun:clogf128=uninstrumented fun:clogf32=uninstrumented fun:clogf32x=uninstrumented fun:clogf64=uninstrumented fun:clogf64x=uninstrumented fun:clogl=uninstrumented fun:clone=uninstrumented fun:close=uninstrumented fun:close_range=uninstrumented fun:closedir=uninstrumented fun:closefrom=uninstrumented fun:closelog=uninstrumented fun:cnd_broadcast=uninstrumented fun:cnd_destroy=uninstrumented fun:cnd_init=uninstrumented fun:cnd_signal=uninstrumented fun:cnd_timedwait=uninstrumented fun:cnd_wait=uninstrumented fun:confstr=uninstrumented fun:conj=uninstrumented fun:conjf=uninstrumented fun:conjf128=uninstrumented fun:conjf32=uninstrumented fun:conjf32x=uninstrumented fun:conjf64=uninstrumented fun:conjf64x=uninstrumented fun:conjl=uninstrumented fun:connect=uninstrumented fun:copy_file_range=uninstrumented fun:copysign=uninstrumented fun:copysignf=uninstrumented fun:copysignf128=uninstrumented fun:copysignf32=uninstrumented fun:copysignf32x=uninstrumented fun:copysignf64=uninstrumented fun:copysignf64x=uninstrumented fun:copysignl=uninstrumented fun:cos=uninstrumented fun:cosf=uninstrumented fun:cosf128=uninstrumented fun:cosf32=uninstrumented fun:cosf32x=uninstrumented fun:cosf64=uninstrumented fun:cosf64x=uninstrumented fun:cosh=uninstrumented fun:coshf=uninstrumented fun:coshf128=uninstrumented fun:coshf32=uninstrumented fun:coshf32x=uninstrumented fun:coshf64=uninstrumented fun:coshf64x=uninstrumented fun:coshl=uninstrumented fun:cosl=uninstrumented fun:cpow=uninstrumented fun:cpowf=uninstrumented fun:cpowf128=uninstrumented fun:cpowf32=uninstrumented fun:cpowf32x=uninstrumented fun:cpowf64=uninstrumented fun:cpowf64x=uninstrumented fun:cpowl=uninstrumented fun:cproj=uninstrumented fun:cprojf=uninstrumented fun:cprojf128=uninstrumented fun:cprojf32=uninstrumented fun:cprojf32x=uninstrumented fun:cprojf64=uninstrumented fun:cprojf64x=uninstrumented fun:cprojl=uninstrumented fun:creal=uninstrumented fun:crealf=uninstrumented fun:crealf128=uninstrumented fun:crealf32=uninstrumented fun:crealf32x=uninstrumented fun:crealf64=uninstrumented fun:crealf64x=uninstrumented fun:creall=uninstrumented fun:creat=uninstrumented fun:creat64=uninstrumented fun:create_module=uninstrumented fun:crypt=uninstrumented fun:crypt_checksalt=uninstrumented fun:crypt_gensalt=uninstrumented fun:crypt_gensalt_r=uninstrumented fun:crypt_gensalt_ra=uninstrumented fun:crypt_gensalt_rn=uninstrumented fun:crypt_preferred_method=uninstrumented fun:crypt_r=uninstrumented fun:crypt_ra=uninstrumented fun:crypt_rn=uninstrumented fun:csin=uninstrumented fun:csinf=uninstrumented fun:csinf128=uninstrumented fun:csinf32=uninstrumented fun:csinf32x=uninstrumented fun:csinf64=uninstrumented fun:csinf64x=uninstrumented fun:csinh=uninstrumented fun:csinhf=uninstrumented fun:csinhf128=uninstrumented fun:csinhf32=uninstrumented fun:csinhf32x=uninstrumented fun:csinhf64=uninstrumented fun:csinhf64x=uninstrumented fun:csinhl=uninstrumented fun:csinl=uninstrumented fun:csqrt=uninstrumented fun:csqrtf=uninstrumented fun:csqrtf128=uninstrumented fun:csqrtf32=uninstrumented fun:csqrtf32x=uninstrumented fun:csqrtf64=uninstrumented fun:csqrtf64x=uninstrumented fun:csqrtl=uninstrumented fun:ctan=uninstrumented fun:ctanf=uninstrumented fun:ctanf128=uninstrumented fun:ctanf32=uninstrumented fun:ctanf32x=uninstrumented fun:ctanf64=uninstrumented fun:ctanf64x=uninstrumented fun:ctanh=uninstrumented fun:ctanhf=uninstrumented fun:ctanhf128=uninstrumented fun:ctanhf32=uninstrumented fun:ctanhf32x=uninstrumented fun:ctanhf64=uninstrumented fun:ctanhf64x=uninstrumented fun:ctanhl=uninstrumented fun:ctanl=uninstrumented fun:ctermid=uninstrumented fun:ctime=uninstrumented fun:ctime_r=uninstrumented fun:cuserid=uninstrumented fun:daddl=uninstrumented fun:daemon=uninstrumented fun:dcgettext=uninstrumented fun:dcngettext=uninstrumented fun:ddivl=uninstrumented fun:delete_module=uninstrumented fun:des_setparity=uninstrumented fun:dfmal=uninstrumented fun:dgettext=uninstrumented fun:difftime=uninstrumented fun:dirfd=uninstrumented fun:dirname=uninstrumented fun:div=uninstrumented fun:dl_iterate_phdr=uninstrumented fun:dladdr=uninstrumented fun:dladdr1=uninstrumented fun:dlclose=uninstrumented fun:dlerror=uninstrumented fun:dlinfo=uninstrumented fun:dlmopen=uninstrumented fun:dlopen=uninstrumented fun:dlsym=uninstrumented fun:dlvsym=uninstrumented fun:dmull=uninstrumented fun:dn_comp=uninstrumented fun:dn_expand=uninstrumented fun:dn_skipname=uninstrumented fun:dngettext=uninstrumented fun:dprintf=uninstrumented fun:drand48=uninstrumented fun:drand48_r=uninstrumented fun:drem=uninstrumented fun:dremf=uninstrumented fun:dreml=uninstrumented fun:dsqrtl=uninstrumented fun:dsubl=uninstrumented fun:dup=uninstrumented fun:dup2=uninstrumented fun:dup3=uninstrumented fun:duplocale=uninstrumented fun:dysize=uninstrumented fun:eaccess=uninstrumented fun:ecb_crypt=uninstrumented fun:ecvt=uninstrumented fun:ecvt_r=uninstrumented fun:encrypt=uninstrumented fun:encrypt_r=uninstrumented fun:endaliasent=uninstrumented fun:endfsent=uninstrumented fun:endgrent=uninstrumented fun:endhostent=uninstrumented fun:endmntent=uninstrumented fun:endnetent=uninstrumented fun:endnetgrent=uninstrumented fun:endprotoent=uninstrumented fun:endpwent=uninstrumented fun:endrpcent=uninstrumented fun:endservent=uninstrumented fun:endsgent=uninstrumented fun:endspent=uninstrumented fun:endttyent=uninstrumented fun:endusershell=uninstrumented fun:endutent=uninstrumented fun:endutxent=uninstrumented fun:envz_add=uninstrumented fun:envz_entry=uninstrumented fun:envz_get=uninstrumented fun:envz_merge=uninstrumented fun:envz_remove=uninstrumented fun:envz_strip=uninstrumented fun:epoll_create=uninstrumented fun:epoll_create1=uninstrumented fun:epoll_ctl=uninstrumented fun:epoll_pwait=uninstrumented fun:epoll_pwait2=uninstrumented fun:epoll_wait=uninstrumented fun:erand48=uninstrumented fun:erand48_r=uninstrumented fun:erf=uninstrumented fun:erfc=uninstrumented fun:erfcf=uninstrumented fun:erfcf128=uninstrumented fun:erfcf32=uninstrumented fun:erfcf32x=uninstrumented fun:erfcf64=uninstrumented fun:erfcf64x=uninstrumented fun:erfcl=uninstrumented fun:erff=uninstrumented fun:erff128=uninstrumented fun:erff32=uninstrumented fun:erff32x=uninstrumented fun:erff64=uninstrumented fun:erff64x=uninstrumented fun:erfl=uninstrumented fun:err=uninstrumented fun:error=uninstrumented fun:error_at_line=uninstrumented fun:errx=uninstrumented fun:ether_aton=uninstrumented fun:ether_aton_r=uninstrumented fun:ether_hostton=uninstrumented fun:ether_line=uninstrumented fun:ether_ntoa=uninstrumented fun:ether_ntoa_r=uninstrumented fun:ether_ntohost=uninstrumented fun:euidaccess=uninstrumented fun:eventfd=uninstrumented fun:eventfd_read=uninstrumented fun:eventfd_write=uninstrumented fun:execl=uninstrumented fun:execle=uninstrumented fun:execlp=uninstrumented fun:execv=uninstrumented fun:execve=uninstrumented fun:execveat=uninstrumented fun:execvp=uninstrumented fun:execvpe=uninstrumented fun:exit=uninstrumented fun:exp=uninstrumented fun:exp10=uninstrumented fun:exp10f=uninstrumented fun:exp10f128=uninstrumented fun:exp10f32=uninstrumented fun:exp10f32x=uninstrumented fun:exp10f64=uninstrumented fun:exp10f64x=uninstrumented fun:exp10l=uninstrumented fun:exp2=uninstrumented fun:exp2f=uninstrumented fun:exp2f128=uninstrumented fun:exp2f32=uninstrumented fun:exp2f32x=uninstrumented fun:exp2f64=uninstrumented fun:exp2f64x=uninstrumented fun:exp2l=uninstrumented fun:expf=uninstrumented fun:expf128=uninstrumented fun:expf32=uninstrumented fun:expf32x=uninstrumented fun:expf64=uninstrumented fun:expf64x=uninstrumented fun:expl=uninstrumented fun:explicit_bzero=uninstrumented fun:expm1=uninstrumented fun:expm1f=uninstrumented fun:expm1f128=uninstrumented fun:expm1f32=uninstrumented fun:expm1f32x=uninstrumented fun:expm1f64=uninstrumented fun:expm1f64x=uninstrumented fun:expm1l=uninstrumented fun:f32addf128=uninstrumented fun:f32addf32x=uninstrumented fun:f32addf64=uninstrumented fun:f32addf64x=uninstrumented fun:f32divf128=uninstrumented fun:f32divf32x=uninstrumented fun:f32divf64=uninstrumented fun:f32divf64x=uninstrumented fun:f32fmaf128=uninstrumented fun:f32fmaf32x=uninstrumented fun:f32fmaf64=uninstrumented fun:f32fmaf64x=uninstrumented fun:f32mulf128=uninstrumented fun:f32mulf32x=uninstrumented fun:f32mulf64=uninstrumented fun:f32mulf64x=uninstrumented fun:f32sqrtf128=uninstrumented fun:f32sqrtf32x=uninstrumented fun:f32sqrtf64=uninstrumented fun:f32sqrtf64x=uninstrumented fun:f32subf128=uninstrumented fun:f32subf32x=uninstrumented fun:f32subf64=uninstrumented fun:f32subf64x=uninstrumented fun:f32xaddf128=uninstrumented fun:f32xaddf64=uninstrumented fun:f32xaddf64x=uninstrumented fun:f32xdivf128=uninstrumented fun:f32xdivf64=uninstrumented fun:f32xdivf64x=uninstrumented fun:f32xfmaf128=uninstrumented fun:f32xfmaf64=uninstrumented fun:f32xfmaf64x=uninstrumented fun:f32xmulf128=uninstrumented fun:f32xmulf64=uninstrumented fun:f32xmulf64x=uninstrumented fun:f32xsqrtf128=uninstrumented fun:f32xsqrtf64=uninstrumented fun:f32xsqrtf64x=uninstrumented fun:f32xsubf128=uninstrumented fun:f32xsubf64=uninstrumented fun:f32xsubf64x=uninstrumented fun:f64addf128=uninstrumented fun:f64addf64x=uninstrumented fun:f64divf128=uninstrumented fun:f64divf64x=uninstrumented fun:f64fmaf128=uninstrumented fun:f64fmaf64x=uninstrumented fun:f64mulf128=uninstrumented fun:f64mulf64x=uninstrumented fun:f64sqrtf128=uninstrumented fun:f64sqrtf64x=uninstrumented fun:f64subf128=uninstrumented fun:f64subf64x=uninstrumented fun:f64xaddf128=uninstrumented fun:f64xdivf128=uninstrumented fun:f64xfmaf128=uninstrumented fun:f64xmulf128=uninstrumented fun:f64xsqrtf128=uninstrumented fun:f64xsubf128=uninstrumented fun:fabs=uninstrumented fun:fabsf=uninstrumented fun:fabsf128=uninstrumented fun:fabsf32=uninstrumented fun:fabsf32x=uninstrumented fun:fabsf64=uninstrumented fun:fabsf64x=uninstrumented fun:fabsl=uninstrumented fun:faccessat=uninstrumented fun:fadd=uninstrumented fun:faddl=uninstrumented fun:fallocate=uninstrumented fun:fallocate64=uninstrumented fun:fanotify_init=uninstrumented fun:fanotify_mark=uninstrumented fun:fattach=uninstrumented fun:fchdir=uninstrumented fun:fchflags=uninstrumented fun:fchmod=uninstrumented fun:fchmodat=uninstrumented fun:fchown=uninstrumented fun:fchownat=uninstrumented fun:fclose=uninstrumented fun:fcloseall=uninstrumented fun:fcntl=uninstrumented fun:fcntl64=uninstrumented fun:fcrypt=uninstrumented fun:fcvt=uninstrumented fun:fcvt_r=uninstrumented fun:fdatasync=uninstrumented fun:fdetach=uninstrumented fun:fdim=uninstrumented fun:fdimf=uninstrumented fun:fdimf128=uninstrumented fun:fdimf32=uninstrumented fun:fdimf32x=uninstrumented fun:fdimf64=uninstrumented fun:fdimf64x=uninstrumented fun:fdiml=uninstrumented fun:fdiv=uninstrumented fun:fdivl=uninstrumented fun:fdopen=uninstrumented fun:fdopendir=uninstrumented fun:feclearexcept=uninstrumented fun:fedisableexcept=uninstrumented fun:feenableexcept=uninstrumented fun:fegetenv=uninstrumented fun:fegetexcept=uninstrumented fun:fegetexceptflag=uninstrumented fun:fegetmode=uninstrumented fun:fegetround=uninstrumented fun:feholdexcept=uninstrumented fun:feof=uninstrumented fun:feof_unlocked=uninstrumented fun:feraiseexcept=uninstrumented fun:ferror=uninstrumented fun:ferror_unlocked=uninstrumented fun:fesetenv=uninstrumented fun:fesetexcept=uninstrumented fun:fesetexceptflag=uninstrumented fun:fesetmode=uninstrumented fun:fesetround=uninstrumented fun:fetestexcept=uninstrumented fun:fetestexceptflag=uninstrumented fun:feupdateenv=uninstrumented fun:fexecve=uninstrumented fun:fflush=uninstrumented fun:fflush_unlocked=uninstrumented fun:ffma=uninstrumented fun:ffmal=uninstrumented fun:ffs=uninstrumented fun:ffsl=uninstrumented fun:ffsll=uninstrumented fun:fgetc=uninstrumented fun:fgetc_unlocked=uninstrumented fun:fgetgrent=uninstrumented fun:fgetgrent_r=uninstrumented fun:fgetpos=uninstrumented fun:fgetpos64=uninstrumented fun:fgetpwent=uninstrumented fun:fgetpwent_r=uninstrumented fun:fgets=uninstrumented fun:fgets_unlocked=uninstrumented fun:fgetsgent=uninstrumented fun:fgetsgent_r=uninstrumented fun:fgetspent=uninstrumented fun:fgetspent_r=uninstrumented fun:fgetwc=uninstrumented fun:fgetwc_unlocked=uninstrumented fun:fgetws=uninstrumented fun:fgetws_unlocked=uninstrumented fun:fgetxattr=uninstrumented fun:fileno=uninstrumented fun:fileno_unlocked=uninstrumented fun:finite=uninstrumented fun:finitef=uninstrumented fun:finitel=uninstrumented fun:flistxattr=uninstrumented fun:flock=uninstrumented fun:flockfile=uninstrumented fun:floor=uninstrumented fun:floorf=uninstrumented fun:floorf128=uninstrumented fun:floorf32=uninstrumented fun:floorf32x=uninstrumented fun:floorf64=uninstrumented fun:floorf64x=uninstrumented fun:floorl=uninstrumented fun:fma=uninstrumented fun:fmaf=uninstrumented fun:fmaf128=uninstrumented fun:fmaf32=uninstrumented fun:fmaf32x=uninstrumented fun:fmaf64=uninstrumented fun:fmaf64x=uninstrumented fun:fmal=uninstrumented fun:fmax=uninstrumented fun:fmaxf=uninstrumented fun:fmaxf128=uninstrumented fun:fmaxf32=uninstrumented fun:fmaxf32x=uninstrumented fun:fmaxf64=uninstrumented fun:fmaxf64x=uninstrumented fun:fmaximum=uninstrumented fun:fmaximum_mag=uninstrumented fun:fmaximum_mag_num=uninstrumented fun:fmaximum_mag_numf=uninstrumented fun:fmaximum_mag_numf128=uninstrumented fun:fmaximum_mag_numf32=uninstrumented fun:fmaximum_mag_numf32x=uninstrumented fun:fmaximum_mag_numf64=uninstrumented fun:fmaximum_mag_numf64x=uninstrumented fun:fmaximum_mag_numl=uninstrumented fun:fmaximum_magf=uninstrumented fun:fmaximum_magf128=uninstrumented fun:fmaximum_magf32=uninstrumented fun:fmaximum_magf32x=uninstrumented fun:fmaximum_magf64=uninstrumented fun:fmaximum_magf64x=uninstrumented fun:fmaximum_magl=uninstrumented fun:fmaximum_num=uninstrumented fun:fmaximum_numf=uninstrumented fun:fmaximum_numf128=uninstrumented fun:fmaximum_numf32=uninstrumented fun:fmaximum_numf32x=uninstrumented fun:fmaximum_numf64=uninstrumented fun:fmaximum_numf64x=uninstrumented fun:fmaximum_numl=uninstrumented fun:fmaximumf=uninstrumented fun:fmaximumf128=uninstrumented fun:fmaximumf32=uninstrumented fun:fmaximumf32x=uninstrumented fun:fmaximumf64=uninstrumented fun:fmaximumf64x=uninstrumented fun:fmaximuml=uninstrumented fun:fmaxl=uninstrumented fun:fmaxmag=uninstrumented fun:fmaxmagf=uninstrumented fun:fmaxmagf128=uninstrumented fun:fmaxmagf32=uninstrumented fun:fmaxmagf32x=uninstrumented fun:fmaxmagf64=uninstrumented fun:fmaxmagf64x=uninstrumented fun:fmaxmagl=uninstrumented fun:fmemopen=uninstrumented fun:fmin=uninstrumented fun:fminf=uninstrumented fun:fminf128=uninstrumented fun:fminf32=uninstrumented fun:fminf32x=uninstrumented fun:fminf64=uninstrumented fun:fminf64x=uninstrumented fun:fminimum=uninstrumented fun:fminimum_mag=uninstrumented fun:fminimum_mag_num=uninstrumented fun:fminimum_mag_numf=uninstrumented fun:fminimum_mag_numf128=uninstrumented fun:fminimum_mag_numf32=uninstrumented fun:fminimum_mag_numf32x=uninstrumented fun:fminimum_mag_numf64=uninstrumented fun:fminimum_mag_numf64x=uninstrumented fun:fminimum_mag_numl=uninstrumented fun:fminimum_magf=uninstrumented fun:fminimum_magf128=uninstrumented fun:fminimum_magf32=uninstrumented fun:fminimum_magf32x=uninstrumented fun:fminimum_magf64=uninstrumented fun:fminimum_magf64x=uninstrumented fun:fminimum_magl=uninstrumented fun:fminimum_num=uninstrumented fun:fminimum_numf=uninstrumented fun:fminimum_numf128=uninstrumented fun:fminimum_numf32=uninstrumented fun:fminimum_numf32x=uninstrumented fun:fminimum_numf64=uninstrumented fun:fminimum_numf64x=uninstrumented fun:fminimum_numl=uninstrumented fun:fminimumf=uninstrumented fun:fminimumf128=uninstrumented fun:fminimumf32=uninstrumented fun:fminimumf32x=uninstrumented fun:fminimumf64=uninstrumented fun:fminimumf64x=uninstrumented fun:fminimuml=uninstrumented fun:fminl=uninstrumented fun:fminmag=uninstrumented fun:fminmagf=uninstrumented fun:fminmagf128=uninstrumented fun:fminmagf32=uninstrumented fun:fminmagf32x=uninstrumented fun:fminmagf64=uninstrumented fun:fminmagf64x=uninstrumented fun:fminmagl=uninstrumented fun:fmod=uninstrumented fun:fmodf=uninstrumented fun:fmodf128=uninstrumented fun:fmodf32=uninstrumented fun:fmodf32x=uninstrumented fun:fmodf64=uninstrumented fun:fmodf64x=uninstrumented fun:fmodl=uninstrumented fun:fmtmsg=uninstrumented fun:fmul=uninstrumented fun:fmull=uninstrumented fun:fnmatch=uninstrumented fun:fopen=uninstrumented fun:fopen64=uninstrumented fun:fopencookie=uninstrumented fun:fork=uninstrumented fun:forkpty=uninstrumented fun:fpathconf=uninstrumented fun:fprintf=uninstrumented fun:fputc=uninstrumented fun:fputc_unlocked=uninstrumented fun:fputs=uninstrumented fun:fputs_unlocked=uninstrumented fun:fputwc=uninstrumented fun:fputwc_unlocked=uninstrumented fun:fputws=uninstrumented fun:fputws_unlocked=uninstrumented fun:fread=uninstrumented fun:fread_unlocked=uninstrumented fun:free=uninstrumented fun:freeaddrinfo=uninstrumented fun:freeifaddrs=uninstrumented fun:freelocale=uninstrumented fun:fremovexattr=uninstrumented fun:freopen=uninstrumented fun:freopen64=uninstrumented fun:frexp=uninstrumented fun:frexpf=uninstrumented fun:frexpf128=uninstrumented fun:frexpf32=uninstrumented fun:frexpf32x=uninstrumented fun:frexpf64=uninstrumented fun:frexpf64x=uninstrumented fun:frexpl=uninstrumented fun:fromfp=uninstrumented fun:fromfpf=uninstrumented fun:fromfpf128=uninstrumented fun:fromfpf32=uninstrumented fun:fromfpf32x=uninstrumented fun:fromfpf64=uninstrumented fun:fromfpf64x=uninstrumented fun:fromfpl=uninstrumented fun:fromfpx=uninstrumented fun:fromfpxf=uninstrumented fun:fromfpxf128=uninstrumented fun:fromfpxf32=uninstrumented fun:fromfpxf32x=uninstrumented fun:fromfpxf64=uninstrumented fun:fromfpxf64x=uninstrumented fun:fromfpxl=uninstrumented fun:fscanf=uninstrumented fun:fsconfig=uninstrumented fun:fseek=uninstrumented fun:fseeko=uninstrumented fun:fseeko64=uninstrumented fun:fsetpos=uninstrumented fun:fsetpos64=uninstrumented fun:fsetxattr=uninstrumented fun:fsmount=uninstrumented fun:fsopen=uninstrumented fun:fspick=uninstrumented fun:fsqrt=uninstrumented fun:fsqrtl=uninstrumented fun:fstat=uninstrumented fun:fstat64=uninstrumented fun:fstatat=uninstrumented fun:fstatat64=uninstrumented fun:fstatfs=uninstrumented fun:fstatfs64=uninstrumented fun:fstatvfs=uninstrumented fun:fstatvfs64=uninstrumented fun:fsub=uninstrumented fun:fsubl=uninstrumented fun:fsync=uninstrumented fun:ftell=uninstrumented fun:ftello=uninstrumented fun:ftello64=uninstrumented fun:ftime=uninstrumented fun:ftok=uninstrumented fun:ftruncate=uninstrumented fun:ftruncate64=uninstrumented fun:ftrylockfile=uninstrumented fun:fts64_children=uninstrumented fun:fts64_close=uninstrumented fun:fts64_open=uninstrumented fun:fts64_read=uninstrumented fun:fts64_set=uninstrumented fun:fts_children=uninstrumented fun:fts_close=uninstrumented fun:fts_open=uninstrumented fun:fts_read=uninstrumented fun:fts_set=uninstrumented fun:ftw=uninstrumented fun:ftw64=uninstrumented fun:funlockfile=uninstrumented fun:futimens=uninstrumented fun:futimes=uninstrumented fun:futimesat=uninstrumented fun:fwide=uninstrumented fun:fwprintf=uninstrumented fun:fwrite=uninstrumented fun:fwrite_unlocked=uninstrumented fun:fwscanf=uninstrumented fun:gai_cancel=uninstrumented fun:gai_error=uninstrumented fun:gai_strerror=uninstrumented fun:gai_suspend=uninstrumented fun:gamma=uninstrumented fun:gammaf=uninstrumented fun:gammal=uninstrumented fun:gcvt=uninstrumented fun:get_avphys_pages=uninstrumented fun:get_current_dir_name=uninstrumented fun:get_kernel_syms=uninstrumented fun:get_myaddress=uninstrumented fun:get_nprocs=uninstrumented fun:get_nprocs_conf=uninstrumented fun:get_phys_pages=uninstrumented fun:getaddrinfo=uninstrumented fun:getaddrinfo_a=uninstrumented fun:getaliasbyname=uninstrumented fun:getaliasbyname_r=uninstrumented fun:getaliasent=uninstrumented fun:getaliasent_r=uninstrumented fun:getauxval=uninstrumented fun:getc=uninstrumented fun:getc_unlocked=uninstrumented fun:getchar=uninstrumented fun:getchar_unlocked=uninstrumented fun:getcontext=uninstrumented fun:getcpu=uninstrumented fun:getcwd=uninstrumented fun:getdate=uninstrumented fun:getdate_r=uninstrumented fun:getdelim=uninstrumented fun:getdents64=uninstrumented fun:getdirentries=uninstrumented fun:getdirentries64=uninstrumented fun:getdomainname=uninstrumented fun:getdtablesize=uninstrumented fun:getegid=uninstrumented fun:getentropy=uninstrumented fun:getenv=uninstrumented fun:geteuid=uninstrumented fun:getfsent=uninstrumented fun:getfsfile=uninstrumented fun:getfsspec=uninstrumented fun:getgid=uninstrumented fun:getgrent=uninstrumented fun:getgrent_r=uninstrumented fun:getgrgid=uninstrumented fun:getgrgid_r=uninstrumented fun:getgrnam=uninstrumented fun:getgrnam_r=uninstrumented fun:getgrouplist=uninstrumented fun:getgroups=uninstrumented fun:gethostbyaddr=uninstrumented fun:gethostbyaddr_r=uninstrumented fun:gethostbyname=uninstrumented fun:gethostbyname2=uninstrumented fun:gethostbyname2_r=uninstrumented fun:gethostbyname_r=uninstrumented fun:gethostent=uninstrumented fun:gethostent_r=uninstrumented fun:gethostid=uninstrumented fun:gethostname=uninstrumented fun:getifaddrs=uninstrumented fun:getipv4sourcefilter=uninstrumented fun:getitimer=uninstrumented fun:getline=uninstrumented fun:getloadavg=uninstrumented fun:getlogin=uninstrumented fun:getlogin_r=uninstrumented fun:getmntent=uninstrumented fun:getmntent_r=uninstrumented fun:getmsg=uninstrumented fun:getnameinfo=uninstrumented fun:getnetbyaddr=uninstrumented fun:getnetbyaddr_r=uninstrumented fun:getnetbyname=uninstrumented fun:getnetbyname_r=uninstrumented fun:getnetent=uninstrumented fun:getnetent_r=uninstrumented fun:getnetgrent=uninstrumented fun:getnetgrent_r=uninstrumented fun:getnetname=uninstrumented fun:getopt=uninstrumented fun:getopt_long=uninstrumented fun:getopt_long_only=uninstrumented fun:getpagesize=uninstrumented fun:getpass=uninstrumented fun:getpayload=uninstrumented fun:getpayloadf=uninstrumented fun:getpayloadf128=uninstrumented fun:getpayloadf32=uninstrumented fun:getpayloadf32x=uninstrumented fun:getpayloadf64=uninstrumented fun:getpayloadf64x=uninstrumented fun:getpayloadl=uninstrumented fun:getpeername=uninstrumented fun:getpgid=uninstrumented fun:getpgrp=uninstrumented fun:getpid=uninstrumented fun:getpmsg=uninstrumented fun:getppid=uninstrumented fun:getpriority=uninstrumented fun:getprotobyname=uninstrumented fun:getprotobyname_r=uninstrumented fun:getprotobynumber=uninstrumented fun:getprotobynumber_r=uninstrumented fun:getprotoent=uninstrumented fun:getprotoent_r=uninstrumented fun:getpt=uninstrumented fun:getpublickey=uninstrumented fun:getpw=uninstrumented fun:getpwent=uninstrumented fun:getpwent_r=uninstrumented fun:getpwnam=uninstrumented fun:getpwnam_r=uninstrumented fun:getpwuid=uninstrumented fun:getpwuid_r=uninstrumented fun:getrandom=uninstrumented fun:getresgid=uninstrumented fun:getresuid=uninstrumented fun:getrlimit=uninstrumented fun:getrlimit64=uninstrumented fun:getrpcbyname=uninstrumented fun:getrpcbyname_r=uninstrumented fun:getrpcbynumber=uninstrumented fun:getrpcbynumber_r=uninstrumented fun:getrpcent=uninstrumented fun:getrpcent_r=uninstrumented fun:getrpcport=uninstrumented fun:getrusage=uninstrumented fun:gets=uninstrumented fun:getsecretkey=uninstrumented fun:getservbyname=uninstrumented fun:getservbyname_r=uninstrumented fun:getservbyport=uninstrumented fun:getservbyport_r=uninstrumented fun:getservent=uninstrumented fun:getservent_r=uninstrumented fun:getsgent=uninstrumented fun:getsgent_r=uninstrumented fun:getsgnam=uninstrumented fun:getsgnam_r=uninstrumented fun:getsid=uninstrumented fun:getsockname=uninstrumented fun:getsockopt=uninstrumented fun:getsourcefilter=uninstrumented fun:getspent=uninstrumented fun:getspent_r=uninstrumented fun:getspnam=uninstrumented fun:getspnam_r=uninstrumented fun:getsubopt=uninstrumented fun:gettext=uninstrumented fun:gettid=uninstrumented fun:gettimeofday=uninstrumented fun:getttyent=uninstrumented fun:getttynam=uninstrumented fun:getuid=uninstrumented fun:getusershell=uninstrumented fun:getutent=uninstrumented fun:getutent_r=uninstrumented fun:getutid=uninstrumented fun:getutid_r=uninstrumented fun:getutline=uninstrumented fun:getutline_r=uninstrumented fun:getutmp=uninstrumented fun:getutmpx=uninstrumented fun:getutxent=uninstrumented fun:getutxid=uninstrumented fun:getutxline=uninstrumented fun:getw=uninstrumented fun:getwc=uninstrumented fun:getwc_unlocked=uninstrumented fun:getwchar=uninstrumented fun:getwchar_unlocked=uninstrumented fun:getwd=uninstrumented fun:getxattr=uninstrumented fun:glob=uninstrumented fun:glob64=uninstrumented fun:glob_pattern_p=uninstrumented fun:globfree=uninstrumented fun:globfree64=uninstrumented fun:gmtime=uninstrumented fun:gmtime_r=uninstrumented fun:gnu_dev_major=uninstrumented fun:gnu_dev_makedev=uninstrumented fun:gnu_dev_minor=uninstrumented fun:gnu_get_libc_release=uninstrumented fun:gnu_get_libc_version=uninstrumented fun:grantpt=uninstrumented fun:group_member=uninstrumented fun:gsignal=uninstrumented fun:gtty=uninstrumented fun:hasmntopt=uninstrumented fun:hcreate=uninstrumented fun:hcreate_r=uninstrumented fun:hdestroy=uninstrumented fun:hdestroy_r=uninstrumented fun:herror=uninstrumented fun:host2netname=uninstrumented fun:hsearch=uninstrumented fun:hsearch_r=uninstrumented fun:hstrerror=uninstrumented fun:htonl=uninstrumented fun:htons=uninstrumented fun:hypot=uninstrumented fun:hypotf=uninstrumented fun:hypotf128=uninstrumented fun:hypotf32=uninstrumented fun:hypotf32x=uninstrumented fun:hypotf64=uninstrumented fun:hypotf64x=uninstrumented fun:hypotl=uninstrumented fun:iconv=uninstrumented fun:iconv_close=uninstrumented fun:iconv_open=uninstrumented fun:if_freenameindex=uninstrumented fun:if_indextoname=uninstrumented fun:if_nameindex=uninstrumented fun:if_nametoindex=uninstrumented fun:ilogb=uninstrumented fun:ilogbf=uninstrumented fun:ilogbf128=uninstrumented fun:ilogbf32=uninstrumented fun:ilogbf32x=uninstrumented fun:ilogbf64=uninstrumented fun:ilogbf64x=uninstrumented fun:ilogbl=uninstrumented fun:imaxabs=uninstrumented fun:imaxdiv=uninstrumented fun:index=uninstrumented fun:inet6_opt_append=uninstrumented fun:inet6_opt_find=uninstrumented fun:inet6_opt_finish=uninstrumented fun:inet6_opt_get_val=uninstrumented fun:inet6_opt_init=uninstrumented fun:inet6_opt_next=uninstrumented fun:inet6_opt_set_val=uninstrumented fun:inet6_option_alloc=uninstrumented fun:inet6_option_append=uninstrumented fun:inet6_option_find=uninstrumented fun:inet6_option_init=uninstrumented fun:inet6_option_next=uninstrumented fun:inet6_option_space=uninstrumented fun:inet6_rth_add=uninstrumented fun:inet6_rth_getaddr=uninstrumented fun:inet6_rth_init=uninstrumented fun:inet6_rth_reverse=uninstrumented fun:inet6_rth_segments=uninstrumented fun:inet6_rth_space=uninstrumented fun:inet_addr=uninstrumented fun:inet_aton=uninstrumented fun:inet_lnaof=uninstrumented fun:inet_makeaddr=uninstrumented fun:inet_net_ntop=uninstrumented fun:inet_net_pton=uninstrumented fun:inet_neta=uninstrumented fun:inet_netof=uninstrumented fun:inet_network=uninstrumented fun:inet_nsap_addr=uninstrumented fun:inet_nsap_ntoa=uninstrumented fun:inet_ntoa=uninstrumented fun:inet_ntop=uninstrumented fun:inet_pton=uninstrumented fun:init_module=uninstrumented fun:initgroups=uninstrumented fun:initstate=uninstrumented fun:initstate_r=uninstrumented fun:innetgr=uninstrumented fun:inotify_add_watch=uninstrumented fun:inotify_init=uninstrumented fun:inotify_init1=uninstrumented fun:inotify_rm_watch=uninstrumented fun:insque=uninstrumented fun:ioctl=uninstrumented fun:ioperm=uninstrumented fun:iopl=uninstrumented fun:iruserok=uninstrumented fun:iruserok_af=uninstrumented fun:isalnum=uninstrumented fun:isalnum_l=uninstrumented fun:isalpha=uninstrumented fun:isalpha_l=uninstrumented fun:isascii=uninstrumented fun:isastream=uninstrumented fun:isatty=uninstrumented fun:isblank=uninstrumented fun:isblank_l=uninstrumented fun:iscntrl=uninstrumented fun:iscntrl_l=uninstrumented fun:isctype=uninstrumented fun:isdigit=uninstrumented fun:isdigit_l=uninstrumented fun:isfdtype=uninstrumented fun:isgraph=uninstrumented fun:isgraph_l=uninstrumented fun:isinf=uninstrumented fun:isinfd128=uninstrumented fun:isinfd32=uninstrumented fun:isinfd64=uninstrumented fun:isinff=uninstrumented fun:isinfl=uninstrumented fun:islower=uninstrumented fun:islower_l=uninstrumented fun:isnan=uninstrumented fun:isnanf=uninstrumented fun:isnanl=uninstrumented fun:isprint=uninstrumented fun:isprint_l=uninstrumented fun:ispunct=uninstrumented fun:ispunct_l=uninstrumented fun:isspace=uninstrumented fun:isspace_l=uninstrumented fun:isupper=uninstrumented fun:isupper_l=uninstrumented fun:iswalnum=uninstrumented fun:iswalnum_l=uninstrumented fun:iswalpha=uninstrumented fun:iswalpha_l=uninstrumented fun:iswblank=uninstrumented fun:iswblank_l=uninstrumented fun:iswcntrl=uninstrumented fun:iswcntrl_l=uninstrumented fun:iswctype=uninstrumented fun:iswctype_l=uninstrumented fun:iswdigit=uninstrumented fun:iswdigit_l=uninstrumented fun:iswgraph=uninstrumented fun:iswgraph_l=uninstrumented fun:iswlower=uninstrumented fun:iswlower_l=uninstrumented fun:iswprint=uninstrumented fun:iswprint_l=uninstrumented fun:iswpunct=uninstrumented fun:iswpunct_l=uninstrumented fun:iswspace=uninstrumented fun:iswspace_l=uninstrumented fun:iswupper=uninstrumented fun:iswupper_l=uninstrumented fun:iswxdigit=uninstrumented fun:iswxdigit_l=uninstrumented fun:isxdigit=uninstrumented fun:isxdigit_l=uninstrumented fun:j0=uninstrumented fun:j0f=uninstrumented fun:j0f128=uninstrumented fun:j0f32=uninstrumented fun:j0f32x=uninstrumented fun:j0f64=uninstrumented fun:j0f64x=uninstrumented fun:j0l=uninstrumented fun:j1=uninstrumented fun:j1f=uninstrumented fun:j1f128=uninstrumented fun:j1f32=uninstrumented fun:j1f32x=uninstrumented fun:j1f64=uninstrumented fun:j1f64x=uninstrumented fun:j1l=uninstrumented fun:jn=uninstrumented fun:jnf=uninstrumented fun:jnf128=uninstrumented fun:jnf32=uninstrumented fun:jnf32x=uninstrumented fun:jnf64=uninstrumented fun:jnf64x=uninstrumented fun:jnl=uninstrumented fun:jrand48=uninstrumented fun:jrand48_r=uninstrumented fun:key_decryptsession=uninstrumented fun:key_decryptsession_pk=uninstrumented fun:key_encryptsession=uninstrumented fun:key_encryptsession_pk=uninstrumented fun:key_gendes=uninstrumented fun:key_get_conv=uninstrumented fun:key_secretkey_is_set=uninstrumented fun:key_setnet=uninstrumented fun:key_setsecret=uninstrumented fun:kill=uninstrumented fun:killpg=uninstrumented fun:klogctl=uninstrumented fun:l64a=uninstrumented fun:labs=uninstrumented fun:lchmod=uninstrumented fun:lchown=uninstrumented fun:lckpwdf=uninstrumented fun:lcong48=uninstrumented fun:lcong48_r=uninstrumented fun:ldexp=uninstrumented fun:ldexpf=uninstrumented fun:ldexpf128=uninstrumented fun:ldexpf32=uninstrumented fun:ldexpf32x=uninstrumented fun:ldexpf64=uninstrumented fun:ldexpf64x=uninstrumented fun:ldexpl=uninstrumented fun:ldiv=uninstrumented fun:lfind=uninstrumented fun:lgamma=uninstrumented fun:lgamma_r=uninstrumented fun:lgammaf=uninstrumented fun:lgammaf128=uninstrumented fun:lgammaf128_r=uninstrumented fun:lgammaf32=uninstrumented fun:lgammaf32_r=uninstrumented fun:lgammaf32x=uninstrumented fun:lgammaf32x_r=uninstrumented fun:lgammaf64=uninstrumented fun:lgammaf64_r=uninstrumented fun:lgammaf64x=uninstrumented fun:lgammaf64x_r=uninstrumented fun:lgammaf_r=uninstrumented fun:lgammal=uninstrumented fun:lgammal_r=uninstrumented fun:lgetxattr=uninstrumented fun:link=uninstrumented fun:linkat=uninstrumented fun:lio_listio=uninstrumented fun:lio_listio64=uninstrumented fun:listen=uninstrumented fun:listxattr=uninstrumented fun:llabs=uninstrumented fun:lldiv=uninstrumented fun:llistxattr=uninstrumented fun:llogb=uninstrumented fun:llogbf=uninstrumented fun:llogbf128=uninstrumented fun:llogbf32=uninstrumented fun:llogbf32x=uninstrumented fun:llogbf64=uninstrumented fun:llogbf64x=uninstrumented fun:llogbl=uninstrumented fun:llrint=uninstrumented fun:llrintf=uninstrumented fun:llrintf128=uninstrumented fun:llrintf32=uninstrumented fun:llrintf32x=uninstrumented fun:llrintf64=uninstrumented fun:llrintf64x=uninstrumented fun:llrintl=uninstrumented fun:llround=uninstrumented fun:llroundf=uninstrumented fun:llroundf128=uninstrumented fun:llroundf32=uninstrumented fun:llroundf32x=uninstrumented fun:llroundf64=uninstrumented fun:llroundf64x=uninstrumented fun:llroundl=uninstrumented fun:llseek=uninstrumented fun:localeconv=uninstrumented fun:localtime=uninstrumented fun:localtime_r=uninstrumented fun:lockf=uninstrumented fun:lockf64=uninstrumented fun:log=uninstrumented fun:log10=uninstrumented fun:log10f=uninstrumented fun:log10f128=uninstrumented fun:log10f32=uninstrumented fun:log10f32x=uninstrumented fun:log10f64=uninstrumented fun:log10f64x=uninstrumented fun:log10l=uninstrumented fun:log1p=uninstrumented fun:log1pf=uninstrumented fun:log1pf128=uninstrumented fun:log1pf32=uninstrumented fun:log1pf32x=uninstrumented fun:log1pf64=uninstrumented fun:log1pf64x=uninstrumented fun:log1pl=uninstrumented fun:log2=uninstrumented fun:log2f=uninstrumented fun:log2f128=uninstrumented fun:log2f32=uninstrumented fun:log2f32x=uninstrumented fun:log2f64=uninstrumented fun:log2f64x=uninstrumented fun:log2l=uninstrumented fun:logb=uninstrumented fun:logbf=uninstrumented fun:logbf128=uninstrumented fun:logbf32=uninstrumented fun:logbf32x=uninstrumented fun:logbf64=uninstrumented fun:logbf64x=uninstrumented fun:logbl=uninstrumented fun:logf=uninstrumented fun:logf128=uninstrumented fun:logf32=uninstrumented fun:logf32x=uninstrumented fun:logf64=uninstrumented fun:logf64x=uninstrumented fun:login=uninstrumented fun:login_tty=uninstrumented fun:logl=uninstrumented fun:logout=uninstrumented fun:logwtmp=uninstrumented fun:longjmp=uninstrumented fun:lrand48=uninstrumented fun:lrand48_r=uninstrumented fun:lremovexattr=uninstrumented fun:lrint=uninstrumented fun:lrintf=uninstrumented fun:lrintf128=uninstrumented fun:lrintf32=uninstrumented fun:lrintf32x=uninstrumented fun:lrintf64=uninstrumented fun:lrintf64x=uninstrumented fun:lrintl=uninstrumented fun:lround=uninstrumented fun:lroundf=uninstrumented fun:lroundf128=uninstrumented fun:lroundf32=uninstrumented fun:lroundf32x=uninstrumented fun:lroundf64=uninstrumented fun:lroundf64x=uninstrumented fun:lroundl=uninstrumented fun:lsearch=uninstrumented fun:lseek=uninstrumented fun:lseek64=uninstrumented fun:lsetxattr=uninstrumented fun:lstat=uninstrumented fun:lstat64=uninstrumented fun:lutimes=uninstrumented fun:madvise=uninstrumented fun:makecontext=uninstrumented fun:mallinfo=uninstrumented fun:mallinfo2=uninstrumented fun:malloc=uninstrumented fun:malloc_info=uninstrumented fun:malloc_stats=uninstrumented fun:malloc_trim=uninstrumented fun:malloc_usable_size=uninstrumented fun:mallopt=uninstrumented fun:matherr=uninstrumented fun:mblen=uninstrumented fun:mbrlen=uninstrumented fun:mbrtoc16=uninstrumented fun:mbrtoc32=uninstrumented fun:mbrtoc8=uninstrumented fun:mbrtowc=uninstrumented fun:mbsinit=uninstrumented fun:mbsnrtowcs=uninstrumented fun:mbsrtowcs=uninstrumented fun:mbstowcs=uninstrumented fun:mbtowc=uninstrumented fun:mcheck=uninstrumented fun:mcheck_check_all=uninstrumented fun:mcheck_pedantic=uninstrumented fun:mcount=uninstrumented fun:memalign=uninstrumented fun:memccpy=uninstrumented fun:memchr=uninstrumented fun:memcmp=uninstrumented fun:memcpy=uninstrumented fun:memfd_create=uninstrumented fun:memfrob=uninstrumented fun:memmem=uninstrumented fun:memmove=uninstrumented fun:mempcpy=uninstrumented fun:memrchr=uninstrumented fun:memset=uninstrumented fun:mincore=uninstrumented fun:mkdir=uninstrumented fun:mkdirat=uninstrumented fun:mkdtemp=uninstrumented fun:mkfifo=uninstrumented fun:mkfifoat=uninstrumented fun:mknod=uninstrumented fun:mknodat=uninstrumented fun:mkostemp=uninstrumented fun:mkostemp64=uninstrumented fun:mkostemps=uninstrumented fun:mkostemps64=uninstrumented fun:mkstemp=uninstrumented fun:mkstemp64=uninstrumented fun:mkstemps=uninstrumented fun:mkstemps64=uninstrumented fun:mktemp=uninstrumented fun:mktime=uninstrumented fun:mlock=uninstrumented fun:mlock2=uninstrumented fun:mlockall=uninstrumented fun:mmap=uninstrumented fun:mmap64=uninstrumented fun:modf=uninstrumented fun:modff=uninstrumented fun:modff128=uninstrumented fun:modff32=uninstrumented fun:modff32x=uninstrumented fun:modff64=uninstrumented fun:modff64x=uninstrumented fun:modfl=uninstrumented fun:modify_ldt=uninstrumented fun:moncontrol=uninstrumented fun:monstartup=uninstrumented fun:mount=uninstrumented fun:mount_setattr=uninstrumented fun:move_mount=uninstrumented fun:mprobe=uninstrumented fun:mprotect=uninstrumented fun:mq_close=uninstrumented fun:mq_getattr=uninstrumented fun:mq_notify=uninstrumented fun:mq_open=uninstrumented fun:mq_receive=uninstrumented fun:mq_send=uninstrumented fun:mq_setattr=uninstrumented fun:mq_timedreceive=uninstrumented fun:mq_timedsend=uninstrumented fun:mq_unlink=uninstrumented fun:mrand48=uninstrumented fun:mrand48_r=uninstrumented fun:mremap=uninstrumented fun:msgctl=uninstrumented fun:msgget=uninstrumented fun:msgrcv=uninstrumented fun:msgsnd=uninstrumented fun:msync=uninstrumented fun:mtrace=uninstrumented fun:mtx_destroy=uninstrumented fun:mtx_init=uninstrumented fun:mtx_lock=uninstrumented fun:mtx_timedlock=uninstrumented fun:mtx_trylock=uninstrumented fun:mtx_unlock=uninstrumented fun:munlock=uninstrumented fun:munlockall=uninstrumented fun:munmap=uninstrumented fun:muntrace=uninstrumented fun:name_to_handle_at=uninstrumented fun:nan=uninstrumented fun:nanf=uninstrumented fun:nanf128=uninstrumented fun:nanf32=uninstrumented fun:nanf32x=uninstrumented fun:nanf64=uninstrumented fun:nanf64x=uninstrumented fun:nanl=uninstrumented fun:nanosleep=uninstrumented fun:nearbyint=uninstrumented fun:nearbyintf=uninstrumented fun:nearbyintf128=uninstrumented fun:nearbyintf32=uninstrumented fun:nearbyintf32x=uninstrumented fun:nearbyintf64=uninstrumented fun:nearbyintf64x=uninstrumented fun:nearbyintl=uninstrumented fun:netname2host=uninstrumented fun:netname2user=uninstrumented fun:newlocale=uninstrumented fun:nextafter=uninstrumented fun:nextafterf=uninstrumented fun:nextafterf128=uninstrumented fun:nextafterf32=uninstrumented fun:nextafterf32x=uninstrumented fun:nextafterf64=uninstrumented fun:nextafterf64x=uninstrumented fun:nextafterl=uninstrumented fun:nextdown=uninstrumented fun:nextdownf=uninstrumented fun:nextdownf128=uninstrumented fun:nextdownf32=uninstrumented fun:nextdownf32x=uninstrumented fun:nextdownf64=uninstrumented fun:nextdownf64x=uninstrumented fun:nextdownl=uninstrumented fun:nexttoward=uninstrumented fun:nexttowardf=uninstrumented fun:nexttowardl=uninstrumented fun:nextup=uninstrumented fun:nextupf=uninstrumented fun:nextupf128=uninstrumented fun:nextupf32=uninstrumented fun:nextupf32x=uninstrumented fun:nextupf64=uninstrumented fun:nextupf64x=uninstrumented fun:nextupl=uninstrumented fun:nfsservctl=uninstrumented fun:nftw=uninstrumented fun:nftw64=uninstrumented fun:ngettext=uninstrumented fun:nice=uninstrumented fun:nis_add=uninstrumented fun:nis_add_entry=uninstrumented fun:nis_addmember=uninstrumented fun:nis_checkpoint=uninstrumented fun:nis_clone_directory=uninstrumented fun:nis_clone_object=uninstrumented fun:nis_clone_result=uninstrumented fun:nis_creategroup=uninstrumented fun:nis_destroy_object=uninstrumented fun:nis_destroygroup=uninstrumented fun:nis_dir_cmp=uninstrumented fun:nis_domain_of=uninstrumented fun:nis_domain_of_r=uninstrumented fun:nis_first_entry=uninstrumented fun:nis_free_directory=uninstrumented fun:nis_free_object=uninstrumented fun:nis_free_request=uninstrumented fun:nis_freenames=uninstrumented fun:nis_freeresult=uninstrumented fun:nis_freeservlist=uninstrumented fun:nis_freetags=uninstrumented fun:nis_getnames=uninstrumented fun:nis_getservlist=uninstrumented fun:nis_ismember=uninstrumented fun:nis_leaf_of=uninstrumented fun:nis_leaf_of_r=uninstrumented fun:nis_lerror=uninstrumented fun:nis_list=uninstrumented fun:nis_local_directory=uninstrumented fun:nis_local_group=uninstrumented fun:nis_local_host=uninstrumented fun:nis_local_principal=uninstrumented fun:nis_lookup=uninstrumented fun:nis_mkdir=uninstrumented fun:nis_modify=uninstrumented fun:nis_modify_entry=uninstrumented fun:nis_name_of=uninstrumented fun:nis_name_of_r=uninstrumented fun:nis_next_entry=uninstrumented fun:nis_perror=uninstrumented fun:nis_ping=uninstrumented fun:nis_print_directory=uninstrumented fun:nis_print_entry=uninstrumented fun:nis_print_group=uninstrumented fun:nis_print_group_entry=uninstrumented fun:nis_print_link=uninstrumented fun:nis_print_object=uninstrumented fun:nis_print_result=uninstrumented fun:nis_print_rights=uninstrumented fun:nis_print_table=uninstrumented fun:nis_read_obj=uninstrumented fun:nis_remove=uninstrumented fun:nis_remove_entry=uninstrumented fun:nis_removemember=uninstrumented fun:nis_rmdir=uninstrumented fun:nis_servstate=uninstrumented fun:nis_sperrno=uninstrumented fun:nis_sperror=uninstrumented fun:nis_sperror_r=uninstrumented fun:nis_stats=uninstrumented fun:nis_verifygroup=uninstrumented fun:nis_write_obj=uninstrumented fun:nl_langinfo=uninstrumented fun:nl_langinfo_l=uninstrumented fun:nrand48=uninstrumented fun:nrand48_r=uninstrumented fun:ns_datetosecs=uninstrumented fun:ns_format_ttl=uninstrumented fun:ns_get16=uninstrumented fun:ns_get32=uninstrumented fun:ns_initparse=uninstrumented fun:ns_makecanon=uninstrumented fun:ns_msg_getflag=uninstrumented fun:ns_name_compress=uninstrumented fun:ns_name_ntol=uninstrumented fun:ns_name_ntop=uninstrumented fun:ns_name_pack=uninstrumented fun:ns_name_pton=uninstrumented fun:ns_name_rollback=uninstrumented fun:ns_name_skip=uninstrumented fun:ns_name_uncompress=uninstrumented fun:ns_name_unpack=uninstrumented fun:ns_parse_ttl=uninstrumented fun:ns_parserr=uninstrumented fun:ns_put16=uninstrumented fun:ns_put32=uninstrumented fun:ns_samedomain=uninstrumented fun:ns_samename=uninstrumented fun:ns_skiprr=uninstrumented fun:ns_sprintrr=uninstrumented fun:ns_sprintrrf=uninstrumented fun:ns_subdomain=uninstrumented fun:ntohl=uninstrumented fun:ntohs=uninstrumented fun:ntp_adjtime=uninstrumented fun:ntp_gettime=uninstrumented fun:ntp_gettimex=uninstrumented fun:obstack_free=uninstrumented fun:obstack_printf=uninstrumented fun:obstack_vprintf=uninstrumented fun:on_exit=uninstrumented fun:open=uninstrumented fun:open64=uninstrumented fun:open_by_handle_at=uninstrumented fun:open_memstream=uninstrumented fun:open_tree=uninstrumented fun:open_wmemstream=uninstrumented fun:openat=uninstrumented fun:openat64=uninstrumented fun:opendir=uninstrumented fun:openlog=uninstrumented fun:openpty=uninstrumented fun:parse_printf_format=uninstrumented fun:passwd2des=uninstrumented fun:pathconf=uninstrumented fun:pause=uninstrumented fun:pclose=uninstrumented fun:perror=uninstrumented fun:personality=uninstrumented fun:pidfd_getfd=uninstrumented fun:pidfd_getpid=uninstrumented fun:pidfd_open=uninstrumented fun:pidfd_send_signal=uninstrumented fun:pidfd_spawn=uninstrumented fun:pidfd_spawnp=uninstrumented fun:pipe=uninstrumented fun:pipe2=uninstrumented fun:pivot_root=uninstrumented fun:pkey_alloc=uninstrumented fun:pkey_free=uninstrumented fun:pkey_get=uninstrumented fun:pkey_mprotect=uninstrumented fun:pkey_set=uninstrumented fun:pmap_getmaps=uninstrumented fun:pmap_getport=uninstrumented fun:pmap_rmtcall=uninstrumented fun:pmap_set=uninstrumented fun:pmap_unset=uninstrumented fun:poll=uninstrumented fun:popen=uninstrumented fun:posix_fadvise=uninstrumented fun:posix_fadvise64=uninstrumented fun:posix_fallocate=uninstrumented fun:posix_fallocate64=uninstrumented fun:posix_madvise=uninstrumented fun:posix_memalign=uninstrumented fun:posix_openpt=uninstrumented fun:posix_spawn=uninstrumented fun:posix_spawn_file_actions_addchdir_np=uninstrumented fun:posix_spawn_file_actions_addclose=uninstrumented fun:posix_spawn_file_actions_addclosefrom_np=uninstrumented fun:posix_spawn_file_actions_adddup2=uninstrumented fun:posix_spawn_file_actions_addfchdir_np=uninstrumented fun:posix_spawn_file_actions_addopen=uninstrumented fun:posix_spawn_file_actions_addtcsetpgrp_np=uninstrumented fun:posix_spawn_file_actions_destroy=uninstrumented fun:posix_spawn_file_actions_init=uninstrumented fun:posix_spawnattr_destroy=uninstrumented fun:posix_spawnattr_getcgroup_np=uninstrumented fun:posix_spawnattr_getflags=uninstrumented fun:posix_spawnattr_getpgroup=uninstrumented fun:posix_spawnattr_getschedparam=uninstrumented fun:posix_spawnattr_getschedpolicy=uninstrumented fun:posix_spawnattr_getsigdefault=uninstrumented fun:posix_spawnattr_getsigmask=uninstrumented fun:posix_spawnattr_init=uninstrumented fun:posix_spawnattr_setcgroup_np=uninstrumented fun:posix_spawnattr_setflags=uninstrumented fun:posix_spawnattr_setpgroup=uninstrumented fun:posix_spawnattr_setschedparam=uninstrumented fun:posix_spawnattr_setschedpolicy=uninstrumented fun:posix_spawnattr_setsigdefault=uninstrumented fun:posix_spawnattr_setsigmask=uninstrumented fun:posix_spawnp=uninstrumented fun:pow=uninstrumented fun:pow10=uninstrumented fun:pow10f=uninstrumented fun:pow10l=uninstrumented fun:powf=uninstrumented fun:powf128=uninstrumented fun:powf32=uninstrumented fun:powf32x=uninstrumented fun:powf64=uninstrumented fun:powf64x=uninstrumented fun:powl=uninstrumented fun:ppoll=uninstrumented fun:prctl=uninstrumented fun:pread=uninstrumented fun:pread64=uninstrumented fun:preadv=uninstrumented fun:preadv2=uninstrumented fun:preadv64=uninstrumented fun:preadv64v2=uninstrumented fun:printf=uninstrumented fun:printf_size=uninstrumented fun:printf_size_info=uninstrumented fun:prlimit=uninstrumented fun:prlimit64=uninstrumented fun:process_madvise=uninstrumented fun:process_mrelease=uninstrumented fun:process_vm_readv=uninstrumented fun:process_vm_writev=uninstrumented fun:profil=uninstrumented fun:pselect=uninstrumented fun:psiginfo=uninstrumented fun:psignal=uninstrumented fun:pthread_atfork=uninstrumented fun:pthread_attr_destroy=uninstrumented fun:pthread_attr_getaffinity_np=uninstrumented fun:pthread_attr_getdetachstate=uninstrumented fun:pthread_attr_getguardsize=uninstrumented fun:pthread_attr_getinheritsched=uninstrumented fun:pthread_attr_getschedparam=uninstrumented fun:pthread_attr_getschedpolicy=uninstrumented fun:pthread_attr_getscope=uninstrumented fun:pthread_attr_getsigmask_np=uninstrumented fun:pthread_attr_getstack=uninstrumented fun:pthread_attr_getstackaddr=uninstrumented fun:pthread_attr_getstacksize=uninstrumented fun:pthread_attr_init=uninstrumented fun:pthread_attr_setaffinity_np=uninstrumented fun:pthread_attr_setdetachstate=uninstrumented fun:pthread_attr_setguardsize=uninstrumented fun:pthread_attr_setinheritsched=uninstrumented fun:pthread_attr_setschedparam=uninstrumented fun:pthread_attr_setschedpolicy=uninstrumented fun:pthread_attr_setscope=uninstrumented fun:pthread_attr_setsigmask_np=uninstrumented fun:pthread_attr_setstack=uninstrumented fun:pthread_attr_setstackaddr=uninstrumented fun:pthread_attr_setstacksize=uninstrumented fun:pthread_barrier_destroy=uninstrumented fun:pthread_barrier_init=uninstrumented fun:pthread_barrier_wait=uninstrumented fun:pthread_barrierattr_destroy=uninstrumented fun:pthread_barrierattr_getpshared=uninstrumented fun:pthread_barrierattr_init=uninstrumented fun:pthread_barrierattr_setpshared=uninstrumented fun:pthread_cancel=uninstrumented fun:pthread_clockjoin_np=uninstrumented fun:pthread_cond_broadcast=uninstrumented fun:pthread_cond_clockwait=uninstrumented fun:pthread_cond_destroy=uninstrumented fun:pthread_cond_init=uninstrumented fun:pthread_cond_signal=uninstrumented fun:pthread_cond_timedwait=uninstrumented fun:pthread_cond_wait=uninstrumented fun:pthread_condattr_destroy=uninstrumented fun:pthread_condattr_getclock=uninstrumented fun:pthread_condattr_getpshared=uninstrumented fun:pthread_condattr_init=uninstrumented fun:pthread_condattr_setclock=uninstrumented fun:pthread_condattr_setpshared=uninstrumented fun:pthread_create=uninstrumented fun:pthread_detach=uninstrumented fun:pthread_equal=uninstrumented fun:pthread_exit=uninstrumented fun:pthread_getaffinity_np=uninstrumented fun:pthread_getattr_default_np=uninstrumented fun:pthread_getattr_np=uninstrumented fun:pthread_getconcurrency=uninstrumented fun:pthread_getcpuclockid=uninstrumented fun:pthread_getname_np=uninstrumented fun:pthread_getschedparam=uninstrumented fun:pthread_getspecific=uninstrumented fun:pthread_join=uninstrumented fun:pthread_key_create=uninstrumented fun:pthread_key_delete=uninstrumented fun:pthread_kill=uninstrumented fun:pthread_kill_other_threads_np=uninstrumented fun:pthread_mutex_clocklock=uninstrumented fun:pthread_mutex_consistent=uninstrumented fun:pthread_mutex_consistent_np=uninstrumented fun:pthread_mutex_destroy=uninstrumented fun:pthread_mutex_getprioceiling=uninstrumented fun:pthread_mutex_init=uninstrumented fun:pthread_mutex_lock=uninstrumented fun:pthread_mutex_setprioceiling=uninstrumented fun:pthread_mutex_timedlock=uninstrumented fun:pthread_mutex_trylock=uninstrumented fun:pthread_mutex_unlock=uninstrumented fun:pthread_mutexattr_destroy=uninstrumented fun:pthread_mutexattr_getkind_np=uninstrumented fun:pthread_mutexattr_getprioceiling=uninstrumented fun:pthread_mutexattr_getprotocol=uninstrumented fun:pthread_mutexattr_getpshared=uninstrumented fun:pthread_mutexattr_getrobust=uninstrumented fun:pthread_mutexattr_getrobust_np=uninstrumented fun:pthread_mutexattr_gettype=uninstrumented fun:pthread_mutexattr_init=uninstrumented fun:pthread_mutexattr_setkind_np=uninstrumented fun:pthread_mutexattr_setprioceiling=uninstrumented fun:pthread_mutexattr_setprotocol=uninstrumented fun:pthread_mutexattr_setpshared=uninstrumented fun:pthread_mutexattr_setrobust=uninstrumented fun:pthread_mutexattr_setrobust_np=uninstrumented fun:pthread_mutexattr_settype=uninstrumented fun:pthread_once=uninstrumented fun:pthread_rwlock_clockrdlock=uninstrumented fun:pthread_rwlock_clockwrlock=uninstrumented fun:pthread_rwlock_destroy=uninstrumented fun:pthread_rwlock_init=uninstrumented fun:pthread_rwlock_rdlock=uninstrumented fun:pthread_rwlock_timedrdlock=uninstrumented fun:pthread_rwlock_timedwrlock=uninstrumented fun:pthread_rwlock_tryrdlock=uninstrumented fun:pthread_rwlock_trywrlock=uninstrumented fun:pthread_rwlock_unlock=uninstrumented fun:pthread_rwlock_wrlock=uninstrumented fun:pthread_rwlockattr_destroy=uninstrumented fun:pthread_rwlockattr_getkind_np=uninstrumented fun:pthread_rwlockattr_getpshared=uninstrumented fun:pthread_rwlockattr_init=uninstrumented fun:pthread_rwlockattr_setkind_np=uninstrumented fun:pthread_rwlockattr_setpshared=uninstrumented fun:pthread_self=uninstrumented fun:pthread_setaffinity_np=uninstrumented fun:pthread_setattr_default_np=uninstrumented fun:pthread_setcancelstate=uninstrumented fun:pthread_setcanceltype=uninstrumented fun:pthread_setconcurrency=uninstrumented fun:pthread_setname_np=uninstrumented fun:pthread_setschedparam=uninstrumented fun:pthread_setschedprio=uninstrumented fun:pthread_setspecific=uninstrumented fun:pthread_sigmask=uninstrumented fun:pthread_sigqueue=uninstrumented fun:pthread_spin_destroy=uninstrumented fun:pthread_spin_init=uninstrumented fun:pthread_spin_lock=uninstrumented fun:pthread_spin_trylock=uninstrumented fun:pthread_spin_unlock=uninstrumented fun:pthread_testcancel=uninstrumented fun:pthread_timedjoin_np=uninstrumented fun:pthread_tryjoin_np=uninstrumented fun:pthread_yield=uninstrumented fun:ptrace=uninstrumented fun:ptsname=uninstrumented fun:ptsname_r=uninstrumented fun:putc=uninstrumented fun:putc_unlocked=uninstrumented fun:putchar=uninstrumented fun:putchar_unlocked=uninstrumented fun:putenv=uninstrumented fun:putgrent=uninstrumented fun:putmsg=uninstrumented fun:putpmsg=uninstrumented fun:putpwent=uninstrumented fun:puts=uninstrumented fun:putsgent=uninstrumented fun:putspent=uninstrumented fun:pututline=uninstrumented fun:pututxline=uninstrumented fun:putw=uninstrumented fun:putwc=uninstrumented fun:putwc_unlocked=uninstrumented fun:putwchar=uninstrumented fun:putwchar_unlocked=uninstrumented fun:pvalloc=uninstrumented fun:pwrite=uninstrumented fun:pwrite64=uninstrumented fun:pwritev=uninstrumented fun:pwritev2=uninstrumented fun:pwritev64=uninstrumented fun:pwritev64v2=uninstrumented fun:qecvt=uninstrumented fun:qecvt_r=uninstrumented fun:qfcvt=uninstrumented fun:qfcvt_r=uninstrumented fun:qgcvt=uninstrumented fun:qsort=uninstrumented fun:qsort_r=uninstrumented fun:query_module=uninstrumented fun:quick_exit=uninstrumented fun:quotactl=uninstrumented fun:raise=uninstrumented fun:rand=uninstrumented fun:rand_r=uninstrumented fun:random=uninstrumented fun:random_r=uninstrumented fun:rawmemchr=uninstrumented fun:rcmd=uninstrumented fun:rcmd_af=uninstrumented fun:re_comp=uninstrumented fun:re_compile_fastmap=uninstrumented fun:re_compile_pattern=uninstrumented fun:re_exec=uninstrumented fun:re_match=uninstrumented fun:re_match_2=uninstrumented fun:re_search=uninstrumented fun:re_search_2=uninstrumented fun:re_set_registers=uninstrumented fun:re_set_syntax=uninstrumented fun:read=uninstrumented fun:readColdStartFile=uninstrumented fun:readahead=uninstrumented fun:readdir=uninstrumented fun:readdir64=uninstrumented fun:readdir64_r=uninstrumented fun:readdir_r=uninstrumented fun:readlink=uninstrumented fun:readlinkat=uninstrumented fun:readv=uninstrumented fun:realloc=uninstrumented fun:reallocarray=uninstrumented fun:realpath=uninstrumented fun:reboot=uninstrumented fun:recv=uninstrumented fun:recvfrom=uninstrumented fun:recvmmsg=uninstrumented fun:recvmsg=uninstrumented fun:regcomp=uninstrumented fun:regerror=uninstrumented fun:regexec=uninstrumented fun:regfree=uninstrumented fun:register_printf_function=uninstrumented fun:register_printf_modifier=uninstrumented fun:register_printf_specifier=uninstrumented fun:register_printf_type=uninstrumented fun:registerrpc=uninstrumented fun:remainder=uninstrumented fun:remainderf=uninstrumented fun:remainderf128=uninstrumented fun:remainderf32=uninstrumented fun:remainderf32x=uninstrumented fun:remainderf64=uninstrumented fun:remainderf64x=uninstrumented fun:remainderl=uninstrumented fun:remap_file_pages=uninstrumented fun:remove=uninstrumented fun:removexattr=uninstrumented fun:remque=uninstrumented fun:remquo=uninstrumented fun:remquof=uninstrumented fun:remquof128=uninstrumented fun:remquof32=uninstrumented fun:remquof32x=uninstrumented fun:remquof64=uninstrumented fun:remquof64x=uninstrumented fun:remquol=uninstrumented fun:rename=uninstrumented fun:renameat=uninstrumented fun:renameat2=uninstrumented fun:res_dnok=uninstrumented fun:res_gethostbyaddr=uninstrumented fun:res_gethostbyname=uninstrumented fun:res_gethostbyname2=uninstrumented fun:res_hnok=uninstrumented fun:res_mailok=uninstrumented fun:res_mkquery=uninstrumented fun:res_nmkquery=uninstrumented fun:res_nquery=uninstrumented fun:res_nquerydomain=uninstrumented fun:res_nsearch=uninstrumented fun:res_nsend=uninstrumented fun:res_ownok=uninstrumented fun:res_query=uninstrumented fun:res_querydomain=uninstrumented fun:res_search=uninstrumented fun:res_send=uninstrumented fun:res_send_setqhook=uninstrumented fun:res_send_setrhook=uninstrumented fun:revoke=uninstrumented fun:rewind=uninstrumented fun:rewinddir=uninstrumented fun:rexec=uninstrumented fun:rexec_af=uninstrumented fun:rindex=uninstrumented fun:rint=uninstrumented fun:rintf=uninstrumented fun:rintf128=uninstrumented fun:rintf32=uninstrumented fun:rintf32x=uninstrumented fun:rintf64=uninstrumented fun:rintf64x=uninstrumented fun:rintl=uninstrumented fun:rmdir=uninstrumented fun:round=uninstrumented fun:roundeven=uninstrumented fun:roundevenf=uninstrumented fun:roundevenf128=uninstrumented fun:roundevenf32=uninstrumented fun:roundevenf32x=uninstrumented fun:roundevenf64=uninstrumented fun:roundevenf64x=uninstrumented fun:roundevenl=uninstrumented fun:roundf=uninstrumented fun:roundf128=uninstrumented fun:roundf32=uninstrumented fun:roundf32x=uninstrumented fun:roundf64=uninstrumented fun:roundf64x=uninstrumented fun:roundl=uninstrumented fun:rpmatch=uninstrumented fun:rresvport=uninstrumented fun:rresvport_af=uninstrumented fun:rtime=uninstrumented fun:ruserok=uninstrumented fun:ruserok_af=uninstrumented fun:ruserpass=uninstrumented fun:sbrk=uninstrumented fun:scalb=uninstrumented fun:scalbf=uninstrumented fun:scalbl=uninstrumented fun:scalbln=uninstrumented fun:scalblnf=uninstrumented fun:scalblnf128=uninstrumented fun:scalblnf32=uninstrumented fun:scalblnf32x=uninstrumented fun:scalblnf64=uninstrumented fun:scalblnf64x=uninstrumented fun:scalblnl=uninstrumented fun:scalbn=uninstrumented fun:scalbnf=uninstrumented fun:scalbnf128=uninstrumented fun:scalbnf32=uninstrumented fun:scalbnf32x=uninstrumented fun:scalbnf64=uninstrumented fun:scalbnf64x=uninstrumented fun:scalbnl=uninstrumented fun:scandir=uninstrumented fun:scandir64=uninstrumented fun:scandirat=uninstrumented fun:scandirat64=uninstrumented fun:scanf=uninstrumented fun:sched_get_priority_max=uninstrumented fun:sched_get_priority_min=uninstrumented fun:sched_getaffinity=uninstrumented fun:sched_getcpu=uninstrumented fun:sched_getparam=uninstrumented fun:sched_getscheduler=uninstrumented fun:sched_rr_get_interval=uninstrumented fun:sched_setaffinity=uninstrumented fun:sched_setparam=uninstrumented fun:sched_setscheduler=uninstrumented fun:sched_yield=uninstrumented fun:secure_getenv=uninstrumented fun:seed48=uninstrumented fun:seed48_r=uninstrumented fun:seekdir=uninstrumented fun:select=uninstrumented fun:sem_clockwait=uninstrumented fun:sem_close=uninstrumented fun:sem_destroy=uninstrumented fun:sem_getvalue=uninstrumented fun:sem_init=uninstrumented fun:sem_open=uninstrumented fun:sem_post=uninstrumented fun:sem_timedwait=uninstrumented fun:sem_trywait=uninstrumented fun:sem_unlink=uninstrumented fun:sem_wait=uninstrumented fun:semctl=uninstrumented fun:semget=uninstrumented fun:semop=uninstrumented fun:semtimedop=uninstrumented fun:send=uninstrumented fun:sendfile=uninstrumented fun:sendfile64=uninstrumented fun:sendmmsg=uninstrumented fun:sendmsg=uninstrumented fun:sendto=uninstrumented fun:setaliasent=uninstrumented fun:setbuf=uninstrumented fun:setbuffer=uninstrumented fun:setcontext=uninstrumented fun:setdomainname=uninstrumented fun:setegid=uninstrumented fun:setenv=uninstrumented fun:seteuid=uninstrumented fun:setfsent=uninstrumented fun:setfsgid=uninstrumented fun:setfsuid=uninstrumented fun:setgid=uninstrumented fun:setgrent=uninstrumented fun:setgroups=uninstrumented fun:sethostent=uninstrumented fun:sethostid=uninstrumented fun:sethostname=uninstrumented fun:setipv4sourcefilter=uninstrumented fun:setitimer=uninstrumented fun:setjmp=uninstrumented fun:setkey=uninstrumented fun:setkey_r=uninstrumented fun:setlinebuf=uninstrumented fun:setlocale=uninstrumented fun:setlogin=uninstrumented fun:setlogmask=uninstrumented fun:setmntent=uninstrumented fun:setnetent=uninstrumented fun:setnetgrent=uninstrumented fun:setns=uninstrumented fun:setpayload=uninstrumented fun:setpayloadf=uninstrumented fun:setpayloadf128=uninstrumented fun:setpayloadf32=uninstrumented fun:setpayloadf32x=uninstrumented fun:setpayloadf64=uninstrumented fun:setpayloadf64x=uninstrumented fun:setpayloadl=uninstrumented fun:setpayloadsig=uninstrumented fun:setpayloadsigf=uninstrumented fun:setpayloadsigf128=uninstrumented fun:setpayloadsigf32=uninstrumented fun:setpayloadsigf32x=uninstrumented fun:setpayloadsigf64=uninstrumented fun:setpayloadsigf64x=uninstrumented fun:setpayloadsigl=uninstrumented fun:setpgid=uninstrumented fun:setpgrp=uninstrumented fun:setpriority=uninstrumented fun:setprotoent=uninstrumented fun:setpwent=uninstrumented fun:setregid=uninstrumented fun:setresgid=uninstrumented fun:setresuid=uninstrumented fun:setreuid=uninstrumented fun:setrlimit=uninstrumented fun:setrlimit64=uninstrumented fun:setrpcent=uninstrumented fun:setservent=uninstrumented fun:setsgent=uninstrumented fun:setsid=uninstrumented fun:setsockopt=uninstrumented fun:setsourcefilter=uninstrumented fun:setspent=uninstrumented fun:setstate=uninstrumented fun:setstate_r=uninstrumented fun:settimeofday=uninstrumented fun:setttyent=uninstrumented fun:setuid=uninstrumented fun:setusershell=uninstrumented fun:setutent=uninstrumented fun:setutxent=uninstrumented fun:setvbuf=uninstrumented fun:setxattr=uninstrumented fun:sgetsgent=uninstrumented fun:sgetsgent_r=uninstrumented fun:sgetspent=uninstrumented fun:sgetspent_r=uninstrumented fun:shm_open=uninstrumented fun:shm_unlink=uninstrumented fun:shmat=uninstrumented fun:shmctl=uninstrumented fun:shmdt=uninstrumented fun:shmget=uninstrumented fun:shutdown=uninstrumented fun:sigabbrev_np=uninstrumented fun:sigaction=uninstrumented fun:sigaddset=uninstrumented fun:sigaltstack=uninstrumented fun:sigandset=uninstrumented fun:sigblock=uninstrumented fun:sigdelset=uninstrumented fun:sigdescr_np=uninstrumented fun:sigemptyset=uninstrumented fun:sigfillset=uninstrumented fun:siggetmask=uninstrumented fun:sighold=uninstrumented fun:sigignore=uninstrumented fun:siginterrupt=uninstrumented fun:sigisemptyset=uninstrumented fun:sigismember=uninstrumented fun:siglongjmp=uninstrumented fun:signal=uninstrumented fun:signalfd=uninstrumented fun:significand=uninstrumented fun:significandf=uninstrumented fun:significandl=uninstrumented fun:sigorset=uninstrumented fun:sigpause=uninstrumented fun:sigpending=uninstrumented fun:sigprocmask=uninstrumented fun:sigqueue=uninstrumented fun:sigrelse=uninstrumented fun:sigreturn=uninstrumented fun:sigset=uninstrumented fun:sigsetmask=uninstrumented fun:sigstack=uninstrumented fun:sigsuspend=uninstrumented fun:sigtimedwait=uninstrumented fun:sigvec=uninstrumented fun:sigwait=uninstrumented fun:sigwaitinfo=uninstrumented fun:sin=uninstrumented fun:sincos=uninstrumented fun:sincosf=uninstrumented fun:sincosf128=uninstrumented fun:sincosf32=uninstrumented fun:sincosf32x=uninstrumented fun:sincosf64=uninstrumented fun:sincosf64x=uninstrumented fun:sincosl=uninstrumented fun:sinf=uninstrumented fun:sinf128=uninstrumented fun:sinf32=uninstrumented fun:sinf32x=uninstrumented fun:sinf64=uninstrumented fun:sinf64x=uninstrumented fun:sinh=uninstrumented fun:sinhf=uninstrumented fun:sinhf128=uninstrumented fun:sinhf32=uninstrumented fun:sinhf32x=uninstrumented fun:sinhf64=uninstrumented fun:sinhf64x=uninstrumented fun:sinhl=uninstrumented fun:sinl=uninstrumented fun:sleep=uninstrumented fun:snprintf=uninstrumented fun:sockatmark=uninstrumented fun:socket=uninstrumented fun:socketpair=uninstrumented fun:splice=uninstrumented fun:sprintf=uninstrumented fun:sprofil=uninstrumented fun:sqrt=uninstrumented fun:sqrtf=uninstrumented fun:sqrtf128=uninstrumented fun:sqrtf32=uninstrumented fun:sqrtf32x=uninstrumented fun:sqrtf64=uninstrumented fun:sqrtf64x=uninstrumented fun:sqrtl=uninstrumented fun:srand=uninstrumented fun:srand48=uninstrumented fun:srand48_r=uninstrumented fun:srandom=uninstrumented fun:srandom_r=uninstrumented fun:sscanf=uninstrumented fun:ssignal=uninstrumented fun:sstk=uninstrumented fun:stat=uninstrumented fun:stat64=uninstrumented fun:statfs=uninstrumented fun:statfs64=uninstrumented fun:statvfs=uninstrumented fun:statvfs64=uninstrumented fun:statx=uninstrumented fun:stdc_bit_ceil_uc=uninstrumented fun:stdc_bit_ceil_ui=uninstrumented fun:stdc_bit_ceil_ul=uninstrumented fun:stdc_bit_ceil_ull=uninstrumented fun:stdc_bit_ceil_us=uninstrumented fun:stdc_bit_floor_uc=uninstrumented fun:stdc_bit_floor_ui=uninstrumented fun:stdc_bit_floor_ul=uninstrumented fun:stdc_bit_floor_ull=uninstrumented fun:stdc_bit_floor_us=uninstrumented fun:stdc_bit_width_uc=uninstrumented fun:stdc_bit_width_ui=uninstrumented fun:stdc_bit_width_ul=uninstrumented fun:stdc_bit_width_ull=uninstrumented fun:stdc_bit_width_us=uninstrumented fun:stdc_count_ones_uc=uninstrumented fun:stdc_count_ones_ui=uninstrumented fun:stdc_count_ones_ul=uninstrumented fun:stdc_count_ones_ull=uninstrumented fun:stdc_count_ones_us=uninstrumented fun:stdc_count_zeros_uc=uninstrumented fun:stdc_count_zeros_ui=uninstrumented fun:stdc_count_zeros_ul=uninstrumented fun:stdc_count_zeros_ull=uninstrumented fun:stdc_count_zeros_us=uninstrumented fun:stdc_first_leading_one_uc=uninstrumented fun:stdc_first_leading_one_ui=uninstrumented fun:stdc_first_leading_one_ul=uninstrumented fun:stdc_first_leading_one_ull=uninstrumented fun:stdc_first_leading_one_us=uninstrumented fun:stdc_first_leading_zero_uc=uninstrumented fun:stdc_first_leading_zero_ui=uninstrumented fun:stdc_first_leading_zero_ul=uninstrumented fun:stdc_first_leading_zero_ull=uninstrumented fun:stdc_first_leading_zero_us=uninstrumented fun:stdc_first_trailing_one_uc=uninstrumented fun:stdc_first_trailing_one_ui=uninstrumented fun:stdc_first_trailing_one_ul=uninstrumented fun:stdc_first_trailing_one_ull=uninstrumented fun:stdc_first_trailing_one_us=uninstrumented fun:stdc_first_trailing_zero_uc=uninstrumented fun:stdc_first_trailing_zero_ui=uninstrumented fun:stdc_first_trailing_zero_ul=uninstrumented fun:stdc_first_trailing_zero_ull=uninstrumented fun:stdc_first_trailing_zero_us=uninstrumented fun:stdc_has_single_bit_uc=uninstrumented fun:stdc_has_single_bit_ui=uninstrumented fun:stdc_has_single_bit_ul=uninstrumented fun:stdc_has_single_bit_ull=uninstrumented fun:stdc_has_single_bit_us=uninstrumented fun:stdc_leading_ones_uc=uninstrumented fun:stdc_leading_ones_ui=uninstrumented fun:stdc_leading_ones_ul=uninstrumented fun:stdc_leading_ones_ull=uninstrumented fun:stdc_leading_ones_us=uninstrumented fun:stdc_leading_zeros_uc=uninstrumented fun:stdc_leading_zeros_ui=uninstrumented fun:stdc_leading_zeros_ul=uninstrumented fun:stdc_leading_zeros_ull=uninstrumented fun:stdc_leading_zeros_us=uninstrumented fun:stdc_trailing_ones_uc=uninstrumented fun:stdc_trailing_ones_ui=uninstrumented fun:stdc_trailing_ones_ul=uninstrumented fun:stdc_trailing_ones_ull=uninstrumented fun:stdc_trailing_ones_us=uninstrumented fun:stdc_trailing_zeros_uc=uninstrumented fun:stdc_trailing_zeros_ui=uninstrumented fun:stdc_trailing_zeros_ul=uninstrumented fun:stdc_trailing_zeros_ull=uninstrumented fun:stdc_trailing_zeros_us=uninstrumented fun:step=uninstrumented fun:stime=uninstrumented fun:stpcpy=uninstrumented fun:stpncpy=uninstrumented fun:strcasecmp=uninstrumented fun:strcasecmp_l=uninstrumented fun:strcasestr=uninstrumented fun:strcat=uninstrumented fun:strchr=uninstrumented fun:strchrnul=uninstrumented fun:strcmp=uninstrumented fun:strcoll=uninstrumented fun:strcoll_l=uninstrumented fun:strcpy=uninstrumented fun:strcspn=uninstrumented fun:strdup=uninstrumented fun:strerror=uninstrumented fun:strerror_l=uninstrumented fun:strerror_r=uninstrumented fun:strerrordesc_np=uninstrumented fun:strerrorname_np=uninstrumented fun:strfmon=uninstrumented fun:strfmon_l=uninstrumented fun:strfromd=uninstrumented fun:strfromf=uninstrumented fun:strfromf128=uninstrumented fun:strfromf32=uninstrumented fun:strfromf32x=uninstrumented fun:strfromf64=uninstrumented fun:strfromf64x=uninstrumented fun:strfroml=uninstrumented fun:strfry=uninstrumented fun:strftime=uninstrumented fun:strftime_l=uninstrumented fun:strlcat=uninstrumented fun:strlcpy=uninstrumented fun:strlen=uninstrumented fun:strncasecmp=uninstrumented fun:strncasecmp_l=uninstrumented fun:strncat=uninstrumented fun:strncmp=uninstrumented fun:strncpy=uninstrumented fun:strndup=uninstrumented fun:strnlen=uninstrumented fun:strpbrk=uninstrumented fun:strptime=uninstrumented fun:strptime_l=uninstrumented fun:strrchr=uninstrumented fun:strsep=uninstrumented fun:strsignal=uninstrumented fun:strspn=uninstrumented fun:strstr=uninstrumented fun:strtod=uninstrumented fun:strtod_l=uninstrumented fun:strtof=uninstrumented fun:strtof128=uninstrumented fun:strtof128_l=uninstrumented fun:strtof32=uninstrumented fun:strtof32_l=uninstrumented fun:strtof32x=uninstrumented fun:strtof32x_l=uninstrumented fun:strtof64=uninstrumented fun:strtof64_l=uninstrumented fun:strtof64x=uninstrumented fun:strtof64x_l=uninstrumented fun:strtof_l=uninstrumented fun:strtoimax=uninstrumented fun:strtok=uninstrumented fun:strtok_r=uninstrumented fun:strtol=uninstrumented fun:strtol_l=uninstrumented fun:strtold=uninstrumented fun:strtold_l=uninstrumented fun:strtoll=uninstrumented fun:strtoll_l=uninstrumented fun:strtoq=uninstrumented fun:strtoul=uninstrumented fun:strtoul_l=uninstrumented fun:strtoull=uninstrumented fun:strtoull_l=uninstrumented fun:strtoumax=uninstrumented fun:strtouq=uninstrumented fun:strverscmp=uninstrumented fun:strxfrm=uninstrumented fun:strxfrm_l=uninstrumented fun:stty=uninstrumented fun:svc_exit=uninstrumented fun:svc_getreq=uninstrumented fun:svc_getreq_common=uninstrumented fun:svc_getreq_poll=uninstrumented fun:svc_getreqset=uninstrumented fun:svc_register=uninstrumented fun:svc_run=uninstrumented fun:svc_sendreply=uninstrumented fun:svc_unregister=uninstrumented fun:svcerr_auth=uninstrumented fun:svcerr_decode=uninstrumented fun:svcerr_noproc=uninstrumented fun:svcerr_noprog=uninstrumented fun:svcerr_progvers=uninstrumented fun:svcerr_systemerr=uninstrumented fun:svcerr_weakauth=uninstrumented fun:svcfd_create=uninstrumented fun:svcraw_create=uninstrumented fun:svctcp_create=uninstrumented fun:svcudp_bufcreate=uninstrumented fun:svcudp_create=uninstrumented fun:svcudp_enablecache=uninstrumented fun:svcunix_create=uninstrumented fun:svcunixfd_create=uninstrumented fun:swab=uninstrumented fun:swapcontext=uninstrumented fun:swapoff=uninstrumented fun:swapon=uninstrumented fun:swprintf=uninstrumented fun:swscanf=uninstrumented fun:symlink=uninstrumented fun:symlinkat=uninstrumented fun:sync=uninstrumented fun:sync_file_range=uninstrumented fun:syncfs=uninstrumented fun:syscall=uninstrumented fun:sysconf=uninstrumented fun:sysctl=uninstrumented fun:sysinfo=uninstrumented fun:syslog=uninstrumented fun:system=uninstrumented fun:sysv_signal=uninstrumented fun:tan=uninstrumented fun:tanf=uninstrumented fun:tanf128=uninstrumented fun:tanf32=uninstrumented fun:tanf32x=uninstrumented fun:tanf64=uninstrumented fun:tanf64x=uninstrumented fun:tanh=uninstrumented fun:tanhf=uninstrumented fun:tanhf128=uninstrumented fun:tanhf32=uninstrumented fun:tanhf32x=uninstrumented fun:tanhf64=uninstrumented fun:tanhf64x=uninstrumented fun:tanhl=uninstrumented fun:tanl=uninstrumented fun:tcdrain=uninstrumented fun:tcflow=uninstrumented fun:tcflush=uninstrumented fun:tcgetattr=uninstrumented fun:tcgetpgrp=uninstrumented fun:tcgetsid=uninstrumented fun:tcsendbreak=uninstrumented fun:tcsetattr=uninstrumented fun:tcsetpgrp=uninstrumented fun:td_init=uninstrumented fun:td_log=uninstrumented fun:td_symbol_list=uninstrumented fun:td_ta_clear_event=uninstrumented fun:td_ta_delete=uninstrumented fun:td_ta_enable_stats=uninstrumented fun:td_ta_event_addr=uninstrumented fun:td_ta_event_getmsg=uninstrumented fun:td_ta_get_nthreads=uninstrumented fun:td_ta_get_ph=uninstrumented fun:td_ta_get_stats=uninstrumented fun:td_ta_map_id2thr=uninstrumented fun:td_ta_map_lwp2thr=uninstrumented fun:td_ta_new=uninstrumented fun:td_ta_reset_stats=uninstrumented fun:td_ta_set_event=uninstrumented fun:td_ta_setconcurrency=uninstrumented fun:td_ta_thr_iter=uninstrumented fun:td_ta_tsd_iter=uninstrumented fun:td_thr_clear_event=uninstrumented fun:td_thr_dbresume=uninstrumented fun:td_thr_dbsuspend=uninstrumented fun:td_thr_event_enable=uninstrumented fun:td_thr_event_getmsg=uninstrumented fun:td_thr_get_info=uninstrumented fun:td_thr_getfpregs=uninstrumented fun:td_thr_getgregs=uninstrumented fun:td_thr_getxregs=uninstrumented fun:td_thr_getxregsize=uninstrumented fun:td_thr_set_event=uninstrumented fun:td_thr_setfpregs=uninstrumented fun:td_thr_setgregs=uninstrumented fun:td_thr_setprio=uninstrumented fun:td_thr_setsigpending=uninstrumented fun:td_thr_setxregs=uninstrumented fun:td_thr_sigsetmask=uninstrumented fun:td_thr_tls_get_addr=uninstrumented fun:td_thr_tlsbase=uninstrumented fun:td_thr_tsd=uninstrumented fun:td_thr_validate=uninstrumented fun:tdelete=uninstrumented fun:tdestroy=uninstrumented fun:tee=uninstrumented fun:telldir=uninstrumented fun:tempnam=uninstrumented fun:textdomain=uninstrumented fun:tfind=uninstrumented fun:tgamma=uninstrumented fun:tgammaf=uninstrumented fun:tgammaf128=uninstrumented fun:tgammaf32=uninstrumented fun:tgammaf32x=uninstrumented fun:tgammaf64=uninstrumented fun:tgammaf64x=uninstrumented fun:tgammal=uninstrumented fun:tgkill=uninstrumented fun:thrd_create=uninstrumented fun:thrd_current=uninstrumented fun:thrd_detach=uninstrumented fun:thrd_equal=uninstrumented fun:thrd_exit=uninstrumented fun:thrd_join=uninstrumented fun:thrd_sleep=uninstrumented fun:thrd_yield=uninstrumented fun:time=uninstrumented fun:timegm=uninstrumented fun:timelocal=uninstrumented fun:timer_create=uninstrumented fun:timer_delete=uninstrumented fun:timer_getoverrun=uninstrumented fun:timer_gettime=uninstrumented fun:timer_settime=uninstrumented fun:timerfd_create=uninstrumented fun:timerfd_gettime=uninstrumented fun:timerfd_settime=uninstrumented fun:times=uninstrumented fun:timespec_get=uninstrumented fun:timespec_getres=uninstrumented fun:tmpfile=uninstrumented fun:tmpfile64=uninstrumented fun:tmpnam=uninstrumented fun:tmpnam_r=uninstrumented fun:toascii=uninstrumented fun:tolower=uninstrumented fun:tolower_l=uninstrumented fun:totalorder=uninstrumented fun:totalorderf=uninstrumented fun:totalorderf128=uninstrumented fun:totalorderf32=uninstrumented fun:totalorderf32x=uninstrumented fun:totalorderf64=uninstrumented fun:totalorderf64x=uninstrumented fun:totalorderl=uninstrumented fun:totalordermag=uninstrumented fun:totalordermagf=uninstrumented fun:totalordermagf128=uninstrumented fun:totalordermagf32=uninstrumented fun:totalordermagf32x=uninstrumented fun:totalordermagf64=uninstrumented fun:totalordermagf64x=uninstrumented fun:totalordermagl=uninstrumented fun:toupper=uninstrumented fun:toupper_l=uninstrumented fun:towctrans=uninstrumented fun:towctrans_l=uninstrumented fun:towlower=uninstrumented fun:towlower_l=uninstrumented fun:towupper=uninstrumented fun:towupper_l=uninstrumented fun:tr_break=uninstrumented fun:trunc=uninstrumented fun:truncate=uninstrumented fun:truncate64=uninstrumented fun:truncf=uninstrumented fun:truncf128=uninstrumented fun:truncf32=uninstrumented fun:truncf32x=uninstrumented fun:truncf64=uninstrumented fun:truncf64x=uninstrumented fun:truncl=uninstrumented fun:tsearch=uninstrumented fun:tss_create=uninstrumented fun:tss_delete=uninstrumented fun:tss_get=uninstrumented fun:tss_set=uninstrumented fun:ttyname=uninstrumented fun:ttyname_r=uninstrumented fun:ttyslot=uninstrumented fun:twalk=uninstrumented fun:twalk_r=uninstrumented fun:tzset=uninstrumented fun:ualarm=uninstrumented fun:ufromfp=uninstrumented fun:ufromfpf=uninstrumented fun:ufromfpf128=uninstrumented fun:ufromfpf32=uninstrumented fun:ufromfpf32x=uninstrumented fun:ufromfpf64=uninstrumented fun:ufromfpf64x=uninstrumented fun:ufromfpl=uninstrumented fun:ufromfpx=uninstrumented fun:ufromfpxf=uninstrumented fun:ufromfpxf128=uninstrumented fun:ufromfpxf32=uninstrumented fun:ufromfpxf32x=uninstrumented fun:ufromfpxf64=uninstrumented fun:ufromfpxf64x=uninstrumented fun:ufromfpxl=uninstrumented fun:ulckpwdf=uninstrumented fun:ulimit=uninstrumented fun:umask=uninstrumented fun:umount=uninstrumented fun:umount2=uninstrumented fun:uname=uninstrumented fun:ungetc=uninstrumented fun:ungetwc=uninstrumented fun:unlink=uninstrumented fun:unlinkat=uninstrumented fun:unlockpt=uninstrumented fun:unsetenv=uninstrumented fun:unshare=uninstrumented fun:updwtmp=uninstrumented fun:updwtmpx=uninstrumented fun:uselib=uninstrumented fun:uselocale=uninstrumented fun:user2netname=uninstrumented fun:usleep=uninstrumented fun:ustat=uninstrumented fun:utime=uninstrumented fun:utimensat=uninstrumented fun:utimes=uninstrumented fun:utmpname=uninstrumented fun:utmpxname=uninstrumented fun:valloc=uninstrumented fun:vasprintf=uninstrumented fun:vdprintf=uninstrumented fun:verr=uninstrumented fun:verrx=uninstrumented fun:versionsort=uninstrumented fun:versionsort64=uninstrumented fun:vfork=uninstrumented fun:vfprintf=uninstrumented fun:vfscanf=uninstrumented fun:vfwprintf=uninstrumented fun:vfwscanf=uninstrumented fun:vhangup=uninstrumented fun:vlimit=uninstrumented fun:vmsplice=uninstrumented fun:vprintf=uninstrumented fun:vscanf=uninstrumented fun:vsnprintf=uninstrumented fun:vsprintf=uninstrumented fun:vsscanf=uninstrumented fun:vswprintf=uninstrumented fun:vswscanf=uninstrumented fun:vsyslog=uninstrumented fun:vtimes=uninstrumented fun:vwarn=uninstrumented fun:vwarnx=uninstrumented fun:vwprintf=uninstrumented fun:vwscanf=uninstrumented fun:wait=uninstrumented fun:wait3=uninstrumented fun:wait4=uninstrumented fun:waitid=uninstrumented fun:waitpid=uninstrumented fun:warn=uninstrumented fun:warnx=uninstrumented fun:wcpcpy=uninstrumented fun:wcpncpy=uninstrumented fun:wcrtomb=uninstrumented fun:wcscasecmp=uninstrumented fun:wcscasecmp_l=uninstrumented fun:wcscat=uninstrumented fun:wcschr=uninstrumented fun:wcschrnul=uninstrumented fun:wcscmp=uninstrumented fun:wcscoll=uninstrumented fun:wcscoll_l=uninstrumented fun:wcscpy=uninstrumented fun:wcscspn=uninstrumented fun:wcsdup=uninstrumented fun:wcsftime=uninstrumented fun:wcsftime_l=uninstrumented fun:wcslcat=uninstrumented fun:wcslcpy=uninstrumented fun:wcslen=uninstrumented fun:wcsncasecmp=uninstrumented fun:wcsncasecmp_l=uninstrumented fun:wcsncat=uninstrumented fun:wcsncmp=uninstrumented fun:wcsncpy=uninstrumented fun:wcsnlen=uninstrumented fun:wcsnrtombs=uninstrumented fun:wcspbrk=uninstrumented fun:wcsrchr=uninstrumented fun:wcsrtombs=uninstrumented fun:wcsspn=uninstrumented fun:wcsstr=uninstrumented fun:wcstod=uninstrumented fun:wcstod_l=uninstrumented fun:wcstof=uninstrumented fun:wcstof128=uninstrumented fun:wcstof128_l=uninstrumented fun:wcstof32=uninstrumented fun:wcstof32_l=uninstrumented fun:wcstof32x=uninstrumented fun:wcstof32x_l=uninstrumented fun:wcstof64=uninstrumented fun:wcstof64_l=uninstrumented fun:wcstof64x=uninstrumented fun:wcstof64x_l=uninstrumented fun:wcstof_l=uninstrumented fun:wcstoimax=uninstrumented fun:wcstok=uninstrumented fun:wcstol=uninstrumented fun:wcstol_l=uninstrumented fun:wcstold=uninstrumented fun:wcstold_l=uninstrumented fun:wcstoll=uninstrumented fun:wcstoll_l=uninstrumented fun:wcstombs=uninstrumented fun:wcstoq=uninstrumented fun:wcstoul=uninstrumented fun:wcstoul_l=uninstrumented fun:wcstoull=uninstrumented fun:wcstoull_l=uninstrumented fun:wcstoumax=uninstrumented fun:wcstouq=uninstrumented fun:wcswcs=uninstrumented fun:wcswidth=uninstrumented fun:wcsxfrm=uninstrumented fun:wcsxfrm_l=uninstrumented fun:wctob=uninstrumented fun:wctomb=uninstrumented fun:wctrans=uninstrumented fun:wctrans_l=uninstrumented fun:wctype=uninstrumented fun:wctype_l=uninstrumented fun:wcwidth=uninstrumented fun:wmemchr=uninstrumented fun:wmemcmp=uninstrumented fun:wmemcpy=uninstrumented fun:wmemmove=uninstrumented fun:wmempcpy=uninstrumented fun:wmemset=uninstrumented fun:wordexp=uninstrumented fun:wordfree=uninstrumented fun:wprintf=uninstrumented fun:write=uninstrumented fun:writeColdStartFile=uninstrumented fun:writev=uninstrumented fun:wscanf=uninstrumented fun:xcrypt=uninstrumented fun:xcrypt_gensalt=uninstrumented fun:xcrypt_gensalt_r=uninstrumented fun:xcrypt_r=uninstrumented fun:xdecrypt=uninstrumented fun:xdr_accepted_reply=uninstrumented fun:xdr_array=uninstrumented fun:xdr_authdes_cred=uninstrumented fun:xdr_authdes_verf=uninstrumented fun:xdr_authunix_parms=uninstrumented fun:xdr_bool=uninstrumented fun:xdr_bytes=uninstrumented fun:xdr_callhdr=uninstrumented fun:xdr_callmsg=uninstrumented fun:xdr_cback_data=uninstrumented fun:xdr_char=uninstrumented fun:xdr_cryptkeyarg=uninstrumented fun:xdr_cryptkeyarg2=uninstrumented fun:xdr_cryptkeyres=uninstrumented fun:xdr_des_block=uninstrumented fun:xdr_domainname=uninstrumented fun:xdr_double=uninstrumented fun:xdr_enum=uninstrumented fun:xdr_float=uninstrumented fun:xdr_free=uninstrumented fun:xdr_getcredres=uninstrumented fun:xdr_hyper=uninstrumented fun:xdr_int=uninstrumented fun:xdr_int16_t=uninstrumented fun:xdr_int32_t=uninstrumented fun:xdr_int64_t=uninstrumented fun:xdr_int8_t=uninstrumented fun:xdr_key_netstarg=uninstrumented fun:xdr_key_netstres=uninstrumented fun:xdr_keybuf=uninstrumented fun:xdr_keydat=uninstrumented fun:xdr_keystatus=uninstrumented fun:xdr_long=uninstrumented fun:xdr_longlong_t=uninstrumented fun:xdr_mapname=uninstrumented fun:xdr_netnamestr=uninstrumented fun:xdr_netobj=uninstrumented fun:xdr_obj_p=uninstrumented fun:xdr_opaque=uninstrumented fun:xdr_opaque_auth=uninstrumented fun:xdr_peername=uninstrumented fun:xdr_pmap=uninstrumented fun:xdr_pmaplist=uninstrumented fun:xdr_pointer=uninstrumented fun:xdr_quad_t=uninstrumented fun:xdr_reference=uninstrumented fun:xdr_rejected_reply=uninstrumented fun:xdr_replymsg=uninstrumented fun:xdr_rmtcall_args=uninstrumented fun:xdr_rmtcallres=uninstrumented fun:xdr_short=uninstrumented fun:xdr_sizeof=uninstrumented fun:xdr_string=uninstrumented fun:xdr_u_char=uninstrumented fun:xdr_u_hyper=uninstrumented fun:xdr_u_int=uninstrumented fun:xdr_u_long=uninstrumented fun:xdr_u_longlong_t=uninstrumented fun:xdr_u_quad_t=uninstrumented fun:xdr_u_short=uninstrumented fun:xdr_uint16_t=uninstrumented fun:xdr_uint32_t=uninstrumented fun:xdr_uint64_t=uninstrumented fun:xdr_uint8_t=uninstrumented fun:xdr_union=uninstrumented fun:xdr_unixcred=uninstrumented fun:xdr_valdat=uninstrumented fun:xdr_vector=uninstrumented fun:xdr_void=uninstrumented fun:xdr_wrapstring=uninstrumented fun:xdr_yp_buf=uninstrumented fun:xdr_ypall=uninstrumented fun:xdr_ypbind_binding=uninstrumented fun:xdr_ypbind_resp=uninstrumented fun:xdr_ypbind_resptype=uninstrumented fun:xdr_ypbind_setdom=uninstrumented fun:xdr_ypdelete_args=uninstrumented fun:xdr_ypmap_parms=uninstrumented fun:xdr_ypmaplist=uninstrumented fun:xdr_yppush_status=uninstrumented fun:xdr_yppushresp_xfr=uninstrumented fun:xdr_ypreq_key=uninstrumented fun:xdr_ypreq_nokey=uninstrumented fun:xdr_ypreq_xfr=uninstrumented fun:xdr_ypresp_all=uninstrumented fun:xdr_ypresp_key_val=uninstrumented fun:xdr_ypresp_maplist=uninstrumented fun:xdr_ypresp_master=uninstrumented fun:xdr_ypresp_order=uninstrumented fun:xdr_ypresp_val=uninstrumented fun:xdr_ypresp_xfr=uninstrumented fun:xdr_ypstat=uninstrumented fun:xdr_ypupdate_args=uninstrumented fun:xdr_ypxfrstat=uninstrumented fun:xdrmem_create=uninstrumented fun:xdrrec_create=uninstrumented fun:xdrrec_endofrecord=uninstrumented fun:xdrrec_eof=uninstrumented fun:xdrrec_skiprecord=uninstrumented fun:xdrstdio_create=uninstrumented fun:xencrypt=uninstrumented fun:xprt_register=uninstrumented fun:xprt_unregister=uninstrumented fun:y0=uninstrumented fun:y0f=uninstrumented fun:y0f128=uninstrumented fun:y0f32=uninstrumented fun:y0f32x=uninstrumented fun:y0f64=uninstrumented fun:y0f64x=uninstrumented fun:y0l=uninstrumented fun:y1=uninstrumented fun:y1f=uninstrumented fun:y1f128=uninstrumented fun:y1f32=uninstrumented fun:y1f32x=uninstrumented fun:y1f64=uninstrumented fun:y1f64x=uninstrumented fun:y1l=uninstrumented fun:yn=uninstrumented fun:ynf=uninstrumented fun:ynf128=uninstrumented fun:ynf32=uninstrumented fun:ynf32x=uninstrumented fun:ynf64=uninstrumented fun:ynf64x=uninstrumented fun:ynl=uninstrumented fun:yp_all=uninstrumented fun:yp_bind=uninstrumented fun:yp_first=uninstrumented fun:yp_get_default_domain=uninstrumented fun:yp_maplist=uninstrumented fun:yp_master=uninstrumented fun:yp_match=uninstrumented fun:yp_next=uninstrumented fun:yp_order=uninstrumented fun:yp_unbind=uninstrumented fun:yp_update=uninstrumented fun:ypbinderr_string=uninstrumented fun:yperr_string=uninstrumented fun:ypprot_err=uninstrumented ================================================ FILE: runtime/dfsan/scripts/build-libc-list.py ================================================ #!/usr/bin/env python #===- lib/dfsan/scripts/build-libc-list.py ---------------------------------===# # # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. # See https://llvm.org/LICENSE.txt for license information. # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # #===------------------------------------------------------------------------===# # The purpose of this script is to identify every function symbol in a set of # libraries (in this case, libc and libgcc) so that they can be marked as # uninstrumented, thus allowing the instrumentation pass to treat calls to those # functions correctly. import os import subprocess import sys from optparse import OptionParser def defined_function_list(object): functions = [] readelf_proc = subprocess.Popen(['readelf', '-s', '-W', object], stdout=subprocess.PIPE, universal_newlines=True) readelf = readelf_proc.communicate()[0].split('\n') if readelf_proc.returncode != 0: raise subprocess.CalledProcessError(readelf_proc.returncode, 'readelf') for line in readelf: if (line[31:35] == 'FUNC' or line[31:36] == 'IFUNC') and \ line[39:44] != 'LOCAL' and \ line[55:58] != 'UND': function_name = line[59:].split('@')[0] functions.append(function_name) return functions p = OptionParser() p.add_option('--libc-dso-path', metavar='PATH', help='path to libc DSO directory', default='/lib/x86_64-linux-gnu') p.add_option('--libc-archive-path', metavar='PATH', help='path to libc archive directory', default='/usr/lib/x86_64-linux-gnu') p.add_option('--libgcc-dso-path', metavar='PATH', help='path to libgcc DSO directory', default='/lib/x86_64-linux-gnu') p.add_option('--libgcc-archive-path', metavar='PATH', help='path to libgcc archive directory', default='/usr/lib/gcc/x86_64-linux-gnu/11') p.add_option('--with-libstdcxx', action='store_true', dest='with_libstdcxx', help='include libstdc++ in the list (inadvisable)') p.add_option('--libstdcxx-dso-path', metavar='PATH', help='path to libstdc++ DSO directory', default='/usr/lib/x86_64-linux-gnu') p.add_option('--with-libcxx', action='store_true', dest='with_libcxx', help='include libc++ in the list (inadvisable)') p.add_option('--libcxx-dso-path', metavar='PATH', help='path to libc++ DSO directory', default='/usr/lib/x86_64-linux-gnu') (options, args) = p.parse_args() libs = [os.path.join(options.libc_dso_path, name) for name in ['ld-linux-x86-64.so.2', 'libanl.so.1', 'libBrokenLocale.so.1', 'libcidn.so.1', 'libcrypt.so.1', 'libc.so.6', 'libdl.so.2', 'libm.so.6', 'libnsl.so.1', 'libpthread.so.0', 'libresolv.so.2', 'librt.so.1', 'libthread_db.so.1', 'libutil.so.1']] libs += [os.path.join(options.libc_archive_path, name) for name in ['libc_nonshared.a', 'libpthread_nonshared.a']] libs.append(os.path.join(options.libgcc_dso_path, 'libgcc_s.so.1')) libs.append(os.path.join(options.libgcc_archive_path, 'libgcc.a')) if options.with_libstdcxx: libs.append(os.path.join(options.libstdcxx_dso_path, 'libstdc++.so.6')) if options.with_libcxx: libs.append(os.path.join(options.libcxx_dso_path, 'libc++abi.so.1')) libs.append(os.path.join(options.libcxx_dso_path, 'libc++.so.1')) functions = [] for l in libs: if os.path.exists(l): functions += defined_function_list(l) else: print('warning: library %s not found' % l, file=sys.stderr) functions = list(set(functions)) functions.sort() for f in functions: print('fun:%s=uninstrumented' % f) ================================================ FILE: runtime/dfsan/scripts/check_custom_wrappers.sh ================================================ #!/bin/sh DFSAN_DIR=$(dirname "$0")/../ DFSAN_CUSTOM_TESTS=${DFSAN_DIR}/../../test/dfsan/custom.cc DFSAN_CUSTOM_WRAPPERS=${DFSAN_DIR}/dfsan_custom.cc DFSAN_ABI_LIST=${DFSAN_DIR}/done_abilist.txt DIFFOUT=$(mktemp -q /tmp/tmp.XXXXXXXXXX) ERRORLOG=$(mktemp -q /tmp/tmp.XXXXXXXXXX) DIFF_A=$(mktemp -q /tmp/tmp.XXXXXXXXXX) DIFF_B=$(mktemp -q /tmp/tmp.XXXXXXXXXX) on_exit() { rm -f ${DIFFOUT} 2> /dev/null rm -f ${ERRORLOG} 2> /dev/null rm -f ${DIFF_A} 2> /dev/null rm -f ${DIFF_B} 2> /dev/null } # Ignore __sanitizer_cov_trace* because they are implemented elsewhere. trap on_exit EXIT grep -E "^fun:.*=custom" ${DFSAN_ABI_LIST} \ | grep -v "dfsan_get_label\|__sanitizer_cov_trace" \ | sed "s/^fun:\(.*\)=custom.*/\1/" | sort > $DIFF_A grep -E "__dfsw.*\(" ${DFSAN_CUSTOM_WRAPPERS} \ | grep -v "__sanitizer_cov_trace" \ | sed "s/.*__dfsw_\(.*\)(.*/\1/" | sort > $DIFF_B diff -u $DIFF_A $DIFF_B > ${DIFFOUT} if [ $? -ne 0 ] then echo -n "The following differences between the ABI list and ">> ${ERRORLOG} echo "the implemented custom wrappers have been found:" >> ${ERRORLOG} cat ${DIFFOUT} >> ${ERRORLOG} fi grep -E __dfsw_ ${DFSAN_CUSTOM_WRAPPERS} \ | grep -v "__sanitizer_cov_trace" \ | sed "s/.*__dfsw_\([^(]*\).*/\1/" | sort > $DIFF_A grep -E "^[[:space:]]*test_.*\(\);" ${DFSAN_CUSTOM_TESTS} \ | sed "s/.*test_\(.*\)();/\1/" | sort > $DIFF_B diff -u $DIFF_A $DIFF_B > ${DIFFOUT} if [ $? -ne 0 ] then echo -n "The following differences between the implemented " >> ${ERRORLOG} echo "custom wrappers and the tests have been found:" >> ${ERRORLOG} cat ${DIFFOUT} >> ${ERRORLOG} fi if [ -s ${ERRORLOG} ] then cat ${ERRORLOG} exit 1 fi ================================================ FILE: runtime/dfsan/taint.ld ================================================ OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64") OUTPUT_ARCH(i386:x86-64) ENTRY(_start) SEARCH_DIR("=/usr/local/lib/x86_64-linux-gnu"); SEARCH_DIR("=/lib/x86_64-linux-gnu"); SEARCH_DIR("=/usr/lib/x86_64-linux-gnu"); SEARCH_DIR("=/usr/local/lib64"); SEARCH_DIR("=/lib64"); SEARCH_DIR("=/usr/lib64"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib"); SEARCH_DIR("=/usr/x86_64-linux-gnu/lib64"); SEARCH_DIR("=/usr/x86_64-linux-gnu/lib"); SECTIONS { /* Read-only sections, merged into text segment: */ PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x700000200000)); . = SEGMENT_START("text-segment", 0x700000200000) + SIZEOF_HEADERS; .interp : { *(.interp) } .note.gnu.build-id : { *(.note.gnu.build-id) } .hash : { *(.hash) } .gnu.hash : { *(.gnu.hash) } .dynsym : { *(.dynsym) } .dynstr : { *(.dynstr) } .gnu.version : { *(.gnu.version) } .gnu.version_d : { *(.gnu.version_d) } .gnu.version_r : { *(.gnu.version_r) } .rela.dyn : { *(.rela.init) *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*) *(.rela.fini) *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*) *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*) *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) *(.rela.ctors) *(.rela.dtors) *(.rela.got) *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*) *(.rela.ldata .rela.ldata.* .rela.gnu.linkonce.l.*) *(.rela.lbss .rela.lbss.* .rela.gnu.linkonce.lb.*) *(.rela.lrodata .rela.lrodata.* .rela.gnu.linkonce.lr.*) *(.rela.ifunc) } .rela.plt : { *(.rela.plt) PROVIDE_HIDDEN (__rela_iplt_start = .); *(.rela.iplt) PROVIDE_HIDDEN (__rela_iplt_end = .); } .init : { KEEP (*(SORT_NONE(.init))) } .plt : { *(.plt) *(.iplt) } .plt.got : { *(.plt.got) } .plt.bnd : { *(.plt.bnd) } .text : { *(.text.unlikely .text.*_unlikely .text.unlikely.*) *(.text.exit .text.exit.*) *(.text.startup .text.startup.*) *(.text.hot .text.hot.*) *(.text .stub .text.* .gnu.linkonce.t.*) /* .gnu.warning sections are handled specially by elf32.em. */ *(.gnu.warning) } .fini : { KEEP (*(SORT_NONE(.fini))) } PROVIDE (__etext = .); PROVIDE (_etext = .); PROVIDE (etext = .); .rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) } .rodata1 : { *(.rodata1) } .eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) } .eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) } .gcc_except_table : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) } .gnu_extab : ONLY_IF_RO { *(.gnu_extab*) } /* These sections are generated by the Sun/Oracle C++ compiler. */ .exception_ranges : ONLY_IF_RO { *(.exception_ranges .exception_ranges*) } /* Adjust the address for the data segment. We want to adjust up to the same address within the page on the next page up. */ . = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE)); /* Exception handling */ .eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) } .gnu_extab : ONLY_IF_RW { *(.gnu_extab) } .gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) } .exception_ranges : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) } /* Thread Local Storage sections */ .tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) } .tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } .preinit_array : { PROVIDE_HIDDEN (__preinit_array_start = .); KEEP (*(.preinit_array)) PROVIDE_HIDDEN (__preinit_array_end = .); } .init_array : { PROVIDE_HIDDEN (__init_array_start = .); KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*))) KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors)) PROVIDE_HIDDEN (__init_array_end = .); } .fini_array : { PROVIDE_HIDDEN (__fini_array_start = .); KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*))) KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors)) PROVIDE_HIDDEN (__fini_array_end = .); } .ctors : { /* gcc uses crtbegin.o to find the start of the constructors, so we make sure it is first. Because this is a wildcard, it doesn't matter if the user does not actually link against crtbegin.o; the linker won't look for a file to match a wildcard. The wildcard also means that it doesn't matter which directory crtbegin.o is in. */ KEEP (*crtbegin.o(.ctors)) KEEP (*crtbegin?.o(.ctors)) /* We don't want to include the .ctor section from the crtend.o file until after the sorted ctors. The .ctor section from the crtend file contains the end of ctors marker and it must be last */ KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors)) KEEP (*(SORT(.ctors.*))) KEEP (*(.ctors)) } .dtors : { KEEP (*crtbegin.o(.dtors)) KEEP (*crtbegin?.o(.dtors)) KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors)) KEEP (*(SORT(.dtors.*))) KEEP (*(.dtors)) } .jcr : { KEEP (*(.jcr)) } .data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) } .dynamic : { *(.dynamic) } .got : { *(.got) *(.igot) } . = DATA_SEGMENT_RELRO_END (SIZEOF (.got.plt) >= 24 ? 24 : 0, .); .got.plt : { *(.got.plt) *(.igot.plt) } .data : { *(.data .data.* .gnu.linkonce.d.*) SORT(CONSTRUCTORS) } .data1 : { *(.data1) } _edata = .; PROVIDE (edata = .); . = .; __bss_start = .; .bss : { *(.dynbss) *(.bss .bss.* .gnu.linkonce.b.*) *(COMMON) /* Align here to ensure that the .bss section occupies space up to _end. Align after .bss to ensure correct alignment even if the .bss section disappears because there are no input sections. FIXME: Why do we need it? When there is no .bss section, we don't pad the .data section. */ . = ALIGN(. != 0 ? 64 / 8 : 1); } .lbss : { *(.dynlbss) *(.lbss .lbss.* .gnu.linkonce.lb.*) *(LARGE_COMMON) } . = ALIGN(64 / 8); . = SEGMENT_START("ldata-segment", .); .lrodata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) : { *(.lrodata .lrodata.* .gnu.linkonce.lr.*) } .ldata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) : { *(.ldata .ldata.* .gnu.linkonce.l.*) . = ALIGN(. != 0 ? 64 / 8 : 1); } . = ALIGN(64 / 8); _end = .; PROVIDE (end = .); . = DATA_SEGMENT_END (.); /* Stabs debugging sections. */ .stab 0 : { *(.stab) } .stabstr 0 : { *(.stabstr) } .stab.excl 0 : { *(.stab.excl) } .stab.exclstr 0 : { *(.stab.exclstr) } .stab.index 0 : { *(.stab.index) } .stab.indexstr 0 : { *(.stab.indexstr) } .comment 0 : { *(.comment) } /* DWARF debug sections. Symbols in the DWARF debugging sections are relative to the beginning of the section so we begin them at 0. */ /* DWARF 1 */ .debug 0 : { *(.debug) } .line 0 : { *(.line) } /* GNU DWARF 1 extensions */ .debug_srcinfo 0 : { *(.debug_srcinfo) } .debug_sfnames 0 : { *(.debug_sfnames) } /* DWARF 1.1 and DWARF 2 */ .debug_aranges 0 : { *(.debug_aranges) } .debug_pubnames 0 : { *(.debug_pubnames) } /* DWARF 2 */ .debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) } .debug_abbrev 0 : { *(.debug_abbrev) } .debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end ) } .debug_frame 0 : { *(.debug_frame) } .debug_str 0 : { *(.debug_str) } .debug_loc 0 : { *(.debug_loc) } .debug_macinfo 0 : { *(.debug_macinfo) } /* SGI/MIPS DWARF 2 extensions */ .debug_weaknames 0 : { *(.debug_weaknames) } .debug_funcnames 0 : { *(.debug_funcnames) } .debug_typenames 0 : { *(.debug_typenames) } .debug_varnames 0 : { *(.debug_varnames) } /* DWARF 3 */ .debug_pubtypes 0 : { *(.debug_pubtypes) } .debug_ranges 0 : { *(.debug_ranges) } /* DWARF Extension. */ .debug_macro 0 : { *(.debug_macro) } .gnu.attributes 0 : { KEEP (*(.gnu.attributes)) } /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) } } ================================================ FILE: runtime/dfsan/taint_allocator.cpp ================================================ #include "../sanitizer_common/sanitizer_atomic.h" #include "../sanitizer_common/sanitizer_common.h" #include "dfsan.h" #include "taint_allocator.h" using namespace __sanitizer; namespace __taint { static uptr begin_addr; static atomic_uint64_t next_usable_byte; static uptr end_addr; /** * Initialize allocator memory, * begin: first usable byte * end: first unusable byte */ void allocator_init(uptr begin, uptr end) { begin_addr = begin; atomic_store_relaxed(&next_usable_byte, begin); end_addr = end; } void *allocator_alloc(uptr size) { if (begin_addr == 0) { Report("FATAL: Allocator not initialized\n"); Die(); } uptr retval = atomic_fetch_add(&next_usable_byte, size, memory_order_relaxed); if (retval + size >= end_addr) { Report("FATAL: Allocate size exceeded\n"); Die(); } return reinterpret_cast(retval); } void allocator_dealloc(uptr addr) { // do nothing for now } } // namespace ================================================ FILE: runtime/dfsan/taint_allocator.h ================================================ #ifndef UNION_ALLOCATOR_H #define UNION_ALLOCATOR_H #include "sanitizer_common/sanitizer_internal_defs.h" using __sanitizer::uptr; namespace __taint { void allocator_init(uptr begin, uptr end); void *allocator_alloc(uptr size); void allocator_dealloc(uptr addr); } // namespace #endif // UNION_ALLOCATOR_H ================================================ FILE: runtime/dfsan/union_hashtable.cpp ================================================ #include "sanitizer_common/sanitizer_libc.h" #include "union_hashtable.h" #include "union_util.h" using namespace __taint; union_hashtable::union_hashtable(uint64_t n) { bucket_size = n; bucket = reinterpret_cast( allocator_alloc(n * sizeof(atomic_uintptr_t))); __sanitizer::internal_memset(bucket, 0, n * sizeof(atomic_uintptr_t)); } uint32_t union_hashtable::hash(const dfsan_label_info &key) { return key.hash & (bucket_size - 1); } void union_hashtable::insert(dfsan_label_info *key, dfsan_label entry) { uint32_t index = hash(*key); auto curr = (struct union_hashtable_entry *) allocator_alloc(sizeof(struct union_hashtable_entry)); curr->key = key; curr->entry = entry; uptr p = atomic_load(&bucket[index], memory_order_acquire); while (true) { curr->next = reinterpret_cast(p); if (atomic_compare_exchange_strong(&bucket[index], &p, (uptr)curr, memory_order_seq_cst)) break; // spin until succeed, when fail, p will contain the current head } } option union_hashtable::lookup(const dfsan_label_info &key) { uint64_t index = hash(key); uptr p = atomic_load(&bucket[index], memory_order_acquire); auto curr = reinterpret_cast(p); while (curr) { if (*(curr->key) == key) { return some_dfsan_label(curr->entry); } curr = curr->next; // no data race here } return none(); } ================================================ FILE: runtime/dfsan/union_hashtable.h ================================================ #ifndef UNION_HASHTABLE_H #define UNION_HASHTABLE_H #include #include "sanitizer_common/sanitizer_atomic.h" #include "sanitizer_common/sanitizer_internal_defs.h" #include "taint_allocator.h" #include "union_util.h" #include "dfsan.h" using __sanitizer::atomic_uintptr_t; using __sanitizer::atomic_load; using __sanitizer::atomic_compare_exchange_strong; using __sanitizer::memory_order_acquire; using __sanitizer::memory_order_seq_cst; namespace __taint { struct union_hashtable_entry { dfsan_label_info *key; dfsan_label entry; struct union_hashtable_entry *next; }; class union_hashtable { atomic_uintptr_t *bucket; uint64_t bucket_size; uint32_t hash(const dfsan_label_info &key); public: union_hashtable(uint64_t n); void insert(dfsan_label_info *key, dfsan_label value); option lookup(const dfsan_label_info &key); }; } #endif ================================================ FILE: runtime/dfsan/union_util.cpp ================================================ #include "union_util.h" namespace __taint { /** * Initialize allocator memory, * begin: first usable byte * end: first unusable byte */ option::option(bool isa, dfsan_label l) { this->isa = isa; this->content = l; } option some_dfsan_label(dfsan_label x) { return option(true, x); } option none() { return option(false, 0); } bool option::operator==(option rhs) { if (isa == false) { return rhs.isa == false; } return rhs.isa != false && content == rhs.content; } bool option::operator!=(option rhs) { return !(*this == rhs); } dfsan_label option::operator*() { return this->content; } bool operator==(const dfsan_label_info& lhs, const dfsan_label_info& rhs) { return lhs.l1 == rhs.l1 && lhs.l2 == rhs.l2 && lhs.op == rhs.op && lhs.size == rhs.size && lhs.op1.i == rhs.op1.i && lhs.op2.i == rhs.op2.i; } } ================================================ FILE: runtime/dfsan/union_util.h ================================================ #ifndef UNION_UTIL_H #define UNION_UTIL_H #include "sanitizer_common/sanitizer_internal_defs.h" #include "dfsan.h" using __sanitizer::uptr; using __sanitizer::u32; namespace __taint { class option { bool isa; dfsan_label content; public: option(bool, dfsan_label); bool operator==(option rhs); bool operator!=(option rhs); dfsan_label operator*(); }; option some_dfsan_label(dfsan_label x); option none(); bool operator==(const dfsan_label_info& lhs, const dfsan_label_info& rhs); } // namespace #endif // UNION_UTIL_H ================================================ FILE: runtime/interception/.clang-format ================================================ BasedOnStyle: Google AllowShortIfStatementsOnASingleLine: false IndentPPDirectives: AfterHash ================================================ FILE: runtime/interception/CMakeLists.txt ================================================ # Build for the runtime interception helper library. set(INTERCEPTION_SOURCES interception_linux.cpp interception_mac.cpp interception_win.cpp interception_type_test.cpp ) set(INTERCEPTION_HEADERS interception.h interception_linux.h interception_mac.h interception_win.h ) include_directories(..) set(INTERCEPTION_CFLAGS ${SANITIZER_COMMON_CFLAGS}) append_rtti_flag(OFF INTERCEPTION_CFLAGS) # Silence warnings in system headers with MSVC. if(NOT CLANG_CL) append_list_if(COMPILER_RT_HAS_EXTERNAL_FLAG "/experimental:external /external:W0 /external:anglebrackets" INTERCEPTION_CFLAGS) endif() add_compiler_rt_object_libraries(RTInterception OS ${SANITIZER_COMMON_SUPPORTED_OS} ARCHS ${SANITIZER_COMMON_SUPPORTED_ARCH} SOURCES ${INTERCEPTION_SOURCES} ADDITIONAL_HEADERS ${INTERCEPTION_HEADERS} CFLAGS ${INTERCEPTION_CFLAGS}) if(COMPILER_RT_INCLUDE_TESTS) add_subdirectory(tests) endif() ================================================ FILE: runtime/interception/interception.h ================================================ //===-- interception.h ------------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Machinery for providing replacements/wrappers for system functions. //===----------------------------------------------------------------------===// #ifndef INTERCEPTION_H #define INTERCEPTION_H #include "sanitizer_common/sanitizer_internal_defs.h" #if !SANITIZER_LINUX && !SANITIZER_FREEBSD && !SANITIZER_MAC && \ !SANITIZER_NETBSD && !SANITIZER_WINDOWS && !SANITIZER_FUCHSIA && \ !SANITIZER_SOLARIS # error "Interception doesn't work on this operating system." #endif // These typedefs should be used only in the interceptor definitions to replace // the standard system types (e.g. SSIZE_T instead of ssize_t) typedef __sanitizer::uptr SIZE_T; typedef __sanitizer::sptr SSIZE_T; typedef __sanitizer::sptr PTRDIFF_T; typedef __sanitizer::s64 INTMAX_T; typedef __sanitizer::u64 UINTMAX_T; typedef __sanitizer::OFF_T OFF_T; typedef __sanitizer::OFF64_T OFF64_T; // How to add an interceptor: // Suppose you need to wrap/replace system function (generally, from libc): // int foo(const char *bar, double baz); // You'll need to: // 1) define INTERCEPTOR(int, foo, const char *bar, double baz) { ... } in // your source file. See the notes below for cases when // INTERCEPTOR_WITH_SUFFIX(...) should be used instead. // 2) Call "INTERCEPT_FUNCTION(foo)" prior to the first call of "foo". // INTERCEPT_FUNCTION(foo) evaluates to "true" iff the function was // intercepted successfully. // You can access original function by calling REAL(foo)(bar, baz). // By default, REAL(foo) will be visible only inside your interceptor, and if // you want to use it in other parts of RTL, you'll need to: // 3a) add DECLARE_REAL(int, foo, const char*, double) to a // header file. // However, if the call "INTERCEPT_FUNCTION(foo)" and definition for // INTERCEPTOR(..., foo, ...) are in different files, you'll instead need to: // 3b) add DECLARE_REAL_AND_INTERCEPTOR(int, foo, const char*, double) // to a header file. // Notes: 1. Things may not work properly if macro INTERCEPTOR(...) {...} or // DECLARE_REAL(...) are located inside namespaces. // 2. On Mac you can also use: "OVERRIDE_FUNCTION(foo, zoo)" to // effectively redirect calls from "foo" to "zoo". In this case // you aren't required to implement // INTERCEPTOR(int, foo, const char *bar, double baz) {...} // but instead you'll have to add // DECLARE_REAL(int, foo, const char *bar, double baz) in your // source file (to define a pointer to overriden function). // 3. Some Mac functions have symbol variants discriminated by // additional suffixes, e.g. _$UNIX2003 (see // https://developer.apple.com/library/mac/#releasenotes/Darwin/SymbolVariantsRelNotes/index.html // for more details). To intercept such functions you need to use the // INTERCEPTOR_WITH_SUFFIX(...) macro. // How it works: // To replace system functions on Linux we just need to declare functions // with same names in our library and then obtain the real function pointers // using dlsym(). // There is one complication. A user may also intercept some of the functions // we intercept. To resolve this we declare our interceptors with __interceptor_ // prefix, and then make actual interceptors weak aliases to __interceptor_ // functions. // // This is not so on Mac OS, where the two-level namespace makes // our replacement functions invisible to other libraries. This may be overcomed // using the DYLD_FORCE_FLAT_NAMESPACE, but some errors loading the shared // libraries in Chromium were noticed when doing so. // Instead we create a dylib containing a __DATA,__interpose section that // associates library functions with their wrappers. When this dylib is // preloaded before an executable using DYLD_INSERT_LIBRARIES, it routes all // the calls to interposed functions done through stubs to the wrapper // functions. // As it's decided at compile time which functions are to be intercepted on Mac, // INTERCEPT_FUNCTION() is effectively a no-op on this system. #if SANITIZER_MAC #include // For __DARWIN_ALIAS_C(). // Just a pair of pointers. struct interpose_substitution { const __sanitizer::uptr replacement; const __sanitizer::uptr original; }; // For a function foo() create a global pair of pointers { wrap_foo, foo } in // the __DATA,__interpose section. // As a result all the calls to foo() will be routed to wrap_foo() at runtime. #define INTERPOSER(func_name) __attribute__((used)) \ const interpose_substitution substitution_##func_name[] \ __attribute__((section("__DATA, __interpose"))) = { \ { reinterpret_cast(WRAP(func_name)), \ reinterpret_cast(func_name) } \ } // For a function foo() and a wrapper function bar() create a global pair // of pointers { bar, foo } in the __DATA,__interpose section. // As a result all the calls to foo() will be routed to bar() at runtime. #define INTERPOSER_2(func_name, wrapper_name) __attribute__((used)) \ const interpose_substitution substitution_##func_name[] \ __attribute__((section("__DATA, __interpose"))) = { \ { reinterpret_cast(wrapper_name), \ reinterpret_cast(func_name) } \ } # define WRAP(x) wrap_##x # define WRAPPER_NAME(x) "wrap_"#x # define INTERCEPTOR_ATTRIBUTE # define DECLARE_WRAPPER(ret_type, func, ...) #elif SANITIZER_WINDOWS # define WRAP(x) __asan_wrap_##x # define WRAPPER_NAME(x) "__asan_wrap_"#x # define INTERCEPTOR_ATTRIBUTE __declspec(dllexport) # define DECLARE_WRAPPER(ret_type, func, ...) \ extern "C" ret_type func(__VA_ARGS__); # define DECLARE_WRAPPER_WINAPI(ret_type, func, ...) \ extern "C" __declspec(dllimport) ret_type __stdcall func(__VA_ARGS__); #elif SANITIZER_FREEBSD || SANITIZER_NETBSD # define WRAP(x) __interceptor_ ## x # define WRAPPER_NAME(x) "__interceptor_" #x # define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default"))) // FreeBSD's dynamic linker (incompliantly) gives non-weak symbols higher // priority than weak ones so weak aliases won't work for indirect calls // in position-independent (-fPIC / -fPIE) mode. # define DECLARE_WRAPPER(ret_type, func, ...) \ extern "C" ret_type func(__VA_ARGS__) \ __attribute__((alias("__interceptor_" #func), visibility("default"))); #elif !SANITIZER_FUCHSIA # define WRAP(x) __interceptor_ ## x # define WRAPPER_NAME(x) "__interceptor_" #x # define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default"))) # define DECLARE_WRAPPER(ret_type, func, ...) \ extern "C" ret_type func(__VA_ARGS__) \ __attribute__((weak, alias("__interceptor_" #func), visibility("default"))); #endif #if SANITIZER_FUCHSIA // There is no general interception at all on Fuchsia. // Sanitizer runtimes just define functions directly to preempt them, // and have bespoke ways to access the underlying libc functions. # include # define INTERCEPTOR_ATTRIBUTE __attribute__((visibility("default"))) # define REAL(x) __unsanitized_##x # define DECLARE_REAL(ret_type, func, ...) #elif !SANITIZER_MAC # define PTR_TO_REAL(x) real_##x # define REAL(x) __interception::PTR_TO_REAL(x) # define FUNC_TYPE(x) x##_type # define DECLARE_REAL(ret_type, func, ...) \ typedef ret_type (*FUNC_TYPE(func))(__VA_ARGS__); \ namespace __interception { \ extern FUNC_TYPE(func) PTR_TO_REAL(func); \ } # define ASSIGN_REAL(dst, src) REAL(dst) = REAL(src) #else // SANITIZER_MAC # define REAL(x) x # define DECLARE_REAL(ret_type, func, ...) \ extern "C" ret_type func(__VA_ARGS__); # define ASSIGN_REAL(x, y) #endif // SANITIZER_MAC #if !SANITIZER_FUCHSIA # define DECLARE_REAL_AND_INTERCEPTOR(ret_type, func, ...) \ DECLARE_REAL(ret_type, func, __VA_ARGS__) \ extern "C" ret_type WRAP(func)(__VA_ARGS__); // Declare an interceptor and its wrapper defined in a different translation // unit (ex. asm). # define DECLARE_EXTERN_INTERCEPTOR_AND_WRAPPER(ret_type, func, ...) \ extern "C" ret_type WRAP(func)(__VA_ARGS__); \ extern "C" ret_type func(__VA_ARGS__); #else # define DECLARE_REAL_AND_INTERCEPTOR(ret_type, func, ...) # define DECLARE_EXTERN_INTERCEPTOR_AND_WRAPPER(ret_type, func, ...) #endif // Generally, you don't need to use DEFINE_REAL by itself, as INTERCEPTOR // macros does its job. In exceptional cases you may need to call REAL(foo) // without defining INTERCEPTOR(..., foo, ...). For example, if you override // foo with an interceptor for other function. #if !SANITIZER_MAC && !SANITIZER_FUCHSIA # define DEFINE_REAL(ret_type, func, ...) \ typedef ret_type (*FUNC_TYPE(func))(__VA_ARGS__); \ namespace __interception { \ FUNC_TYPE(func) PTR_TO_REAL(func); \ } #else # define DEFINE_REAL(ret_type, func, ...) #endif #if SANITIZER_FUCHSIA // We need to define the __interceptor_func name just to get // sanitizer_common/scripts/gen_dynamic_list.py to export func. // But we don't need to export __interceptor_func to get that. #define INTERCEPTOR(ret_type, func, ...) \ extern "C"[[ gnu::alias(#func), gnu::visibility("hidden") ]] ret_type \ __interceptor_##func(__VA_ARGS__); \ extern "C" INTERCEPTOR_ATTRIBUTE ret_type func(__VA_ARGS__) #elif !SANITIZER_MAC #define INTERCEPTOR(ret_type, func, ...) \ DEFINE_REAL(ret_type, func, __VA_ARGS__) \ DECLARE_WRAPPER(ret_type, func, __VA_ARGS__) \ extern "C" \ INTERCEPTOR_ATTRIBUTE \ ret_type WRAP(func)(__VA_ARGS__) // We don't need INTERCEPTOR_WITH_SUFFIX on non-Darwin for now. #define INTERCEPTOR_WITH_SUFFIX(ret_type, func, ...) \ INTERCEPTOR(ret_type, func, __VA_ARGS__) #else // SANITIZER_MAC #define INTERCEPTOR_ZZZ(suffix, ret_type, func, ...) \ extern "C" ret_type func(__VA_ARGS__) suffix; \ extern "C" ret_type WRAP(func)(__VA_ARGS__); \ INTERPOSER(func); \ extern "C" INTERCEPTOR_ATTRIBUTE ret_type WRAP(func)(__VA_ARGS__) #define INTERCEPTOR(ret_type, func, ...) \ INTERCEPTOR_ZZZ(/*no symbol variants*/, ret_type, func, __VA_ARGS__) #define INTERCEPTOR_WITH_SUFFIX(ret_type, func, ...) \ INTERCEPTOR_ZZZ(__DARWIN_ALIAS_C(func), ret_type, func, __VA_ARGS__) // Override |overridee| with |overrider|. #define OVERRIDE_FUNCTION(overridee, overrider) \ INTERPOSER_2(overridee, WRAP(overrider)) #endif #if SANITIZER_WINDOWS # define INTERCEPTOR_WINAPI(ret_type, func, ...) \ typedef ret_type (__stdcall *FUNC_TYPE(func))(__VA_ARGS__); \ namespace __interception { \ FUNC_TYPE(func) PTR_TO_REAL(func); \ } \ extern "C" \ INTERCEPTOR_ATTRIBUTE \ ret_type __stdcall WRAP(func)(__VA_ARGS__) #endif // ISO C++ forbids casting between pointer-to-function and pointer-to-object, // so we use casting via an integral type __interception::uptr, // assuming that system is POSIX-compliant. Using other hacks seem // challenging, as we don't even pass function type to // INTERCEPT_FUNCTION macro, only its name. namespace __interception { #if defined(_WIN64) typedef unsigned long long uptr; #else typedef unsigned long uptr; #endif // _WIN64 } // namespace __interception #define INCLUDED_FROM_INTERCEPTION_LIB #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \ SANITIZER_SOLARIS # include "interception_linux.h" # define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func) # define INTERCEPT_FUNCTION_VER(func, symver) \ INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) #elif SANITIZER_MAC # include "interception_mac.h" # define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_MAC(func) # define INTERCEPT_FUNCTION_VER(func, symver) \ INTERCEPT_FUNCTION_VER_MAC(func, symver) #elif SANITIZER_WINDOWS # include "interception_win.h" # define INTERCEPT_FUNCTION(func) INTERCEPT_FUNCTION_WIN(func) # define INTERCEPT_FUNCTION_VER(func, symver) \ INTERCEPT_FUNCTION_VER_WIN(func, symver) #endif #undef INCLUDED_FROM_INTERCEPTION_LIB #endif // INTERCEPTION_H ================================================ FILE: runtime/interception/interception_linux.cpp ================================================ //===-- interception_linux.cpp ----------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Linux-specific interception methods. //===----------------------------------------------------------------------===// #include "interception.h" #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \ SANITIZER_SOLARIS #include // for dlsym() and dlvsym() namespace __interception { #if SANITIZER_NETBSD static int StrCmp(const char *s1, const char *s2) { while (true) { if (*s1 != *s2) return false; if (*s1 == 0) return true; s1++; s2++; } } #endif static void *GetFuncAddr(const char *name, uptr wrapper_addr) { #if SANITIZER_NETBSD // FIXME: Find a better way to handle renames if (StrCmp(name, "sigaction")) name = "__sigaction14"; #endif void *addr = dlsym(RTLD_NEXT, name); if (!addr) { // If the lookup using RTLD_NEXT failed, the sanitizer runtime library is // later in the library search order than the DSO that we are trying to // intercept, which means that we cannot intercept this function. We still // want the address of the real definition, though, so look it up using // RTLD_DEFAULT. addr = dlsym(RTLD_DEFAULT, name); // In case `name' is not loaded, dlsym ends up finding the actual wrapper. // We don't want to intercept the wrapper and have it point to itself. if ((uptr)addr == wrapper_addr) addr = nullptr; } return addr; } bool InterceptFunction(const char *name, uptr *ptr_to_real, uptr func, uptr wrapper) { void *addr = GetFuncAddr(name, wrapper); *ptr_to_real = (uptr)addr; return addr && (func == wrapper); } // dlvsym is a GNU extension supported by some other platforms. #if SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD static void *GetFuncAddr(const char *name, const char *ver) { return dlvsym(RTLD_NEXT, name, ver); } bool InterceptFunction(const char *name, const char *ver, uptr *ptr_to_real, uptr func, uptr wrapper) { void *addr = GetFuncAddr(name, ver); *ptr_to_real = (uptr)addr; return addr && (func == wrapper); } #endif // SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD } // namespace __interception #endif // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || // SANITIZER_SOLARIS ================================================ FILE: runtime/interception/interception_linux.h ================================================ //===-- interception_linux.h ------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Linux-specific interception methods. //===----------------------------------------------------------------------===// #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \ SANITIZER_SOLARIS #if !defined(INCLUDED_FROM_INTERCEPTION_LIB) # error "interception_linux.h should be included from interception library only" #endif #ifndef INTERCEPTION_LINUX_H #define INTERCEPTION_LINUX_H namespace __interception { bool InterceptFunction(const char *name, uptr *ptr_to_real, uptr func, uptr wrapper); bool InterceptFunction(const char *name, const char *ver, uptr *ptr_to_real, uptr func, uptr wrapper); } // namespace __interception #define INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func) \ ::__interception::InterceptFunction( \ #func, \ (::__interception::uptr *) & REAL(func), \ (::__interception::uptr) & (func), \ (::__interception::uptr) & WRAP(func)) // dlvsym is a GNU extension supported by some other platforms. #if SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD #define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \ ::__interception::InterceptFunction( \ #func, symver, \ (::__interception::uptr *) & REAL(func), \ (::__interception::uptr) & (func), \ (::__interception::uptr) & WRAP(func)) #else #define INTERCEPT_FUNCTION_VER_LINUX_OR_FREEBSD(func, symver) \ INTERCEPT_FUNCTION_LINUX_OR_FREEBSD(func) #endif // SANITIZER_GLIBC || SANITIZER_FREEBSD || SANITIZER_NETBSD #endif // INTERCEPTION_LINUX_H #endif // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || // SANITIZER_SOLARIS ================================================ FILE: runtime/interception/interception_mac.cpp ================================================ //===-- interception_mac.cpp ------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Mac-specific interception methods. //===----------------------------------------------------------------------===// #include "interception.h" #if SANITIZER_MAC #endif // SANITIZER_MAC ================================================ FILE: runtime/interception/interception_mac.h ================================================ //===-- interception_mac.h --------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Mac-specific interception methods. //===----------------------------------------------------------------------===// #if SANITIZER_MAC #if !defined(INCLUDED_FROM_INTERCEPTION_LIB) # error "interception_mac.h should be included from interception.h only" #endif #ifndef INTERCEPTION_MAC_H #define INTERCEPTION_MAC_H #define INTERCEPT_FUNCTION_MAC(func) #define INTERCEPT_FUNCTION_VER_MAC(func, symver) #endif // INTERCEPTION_MAC_H #endif // SANITIZER_MAC ================================================ FILE: runtime/interception/interception_type_test.cpp ================================================ //===-- interception_type_test.cpp ------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Compile-time tests of the internal type definitions. //===----------------------------------------------------------------------===// #include "interception.h" #if SANITIZER_LINUX || SANITIZER_MAC #include #include #include COMPILER_CHECK(sizeof(::SIZE_T) == sizeof(size_t)); COMPILER_CHECK(sizeof(::SSIZE_T) == sizeof(ssize_t)); COMPILER_CHECK(sizeof(::PTRDIFF_T) == sizeof(ptrdiff_t)); COMPILER_CHECK(sizeof(::INTMAX_T) == sizeof(intmax_t)); #if !SANITIZER_MAC COMPILER_CHECK(sizeof(::OFF64_T) == sizeof(off64_t)); #endif // The following are the cases when pread (and friends) is used instead of // pread64. In those cases we need OFF_T to match off_t. We don't care about the // rest (they depend on _FILE_OFFSET_BITS setting when building an application). # if SANITIZER_ANDROID || !defined _FILE_OFFSET_BITS || \ _FILE_OFFSET_BITS != 64 COMPILER_CHECK(sizeof(::OFF_T) == sizeof(off_t)); # endif #endif ================================================ FILE: runtime/interception/interception_win.cpp ================================================ //===-- interception_linux.cpp ----------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Windows-specific interception methods. // // This file is implementing several hooking techniques to intercept calls // to functions. The hooks are dynamically installed by modifying the assembly // code. // // The hooking techniques are making assumptions on the way the code is // generated and are safe under these assumptions. // // On 64-bit architecture, there is no direct 64-bit jump instruction. To allow // arbitrary branching on the whole memory space, the notion of trampoline // region is used. A trampoline region is a memory space withing 2G boundary // where it is safe to add custom assembly code to build 64-bit jumps. // // Hooking techniques // ================== // // 1) Detour // // The Detour hooking technique is assuming the presence of an header with // padding and an overridable 2-bytes nop instruction (mov edi, edi). The // nop instruction can safely be replaced by a 2-bytes jump without any need // to save the instruction. A jump to the target is encoded in the function // header and the nop instruction is replaced by a short jump to the header. // // head: 5 x nop head: jmp // func: mov edi, edi --> func: jmp short // [...] real: [...] // // This technique is only implemented on 32-bit architecture. // Most of the time, Windows API are hookable with the detour technique. // // 2) Redirect Jump // // The redirect jump is applicable when the first instruction is a direct // jump. The instruction is replaced by jump to the hook. // // func: jmp