SYMBOL INDEX (9680 symbols across 668 files)

FILE: lib/aho-corasick.cc
  type mold (line 22) | namespace mold {
    function i64 (line 32) | i64 AhoCorasick::find(std::string_view str) {

FILE: lib/atomics.h
  function namespace (line 8) | namespace mold {
  function T (line 34) | T exchange(T val) { return std::atomic<T>::exchange(val, relaxed); }
  function T (line 35) | T operator|=(T val) { return std::atomic<T>::fetch_or(val, relaxed); }

FILE: lib/bitvector.h
  function namespace (line 8) | namespace mold {
  function class (line 36) | class Bitvector {
  function resize (line 41) | void resize(i64 n) {

FILE: lib/compress.cc
  type mold (line 29) | namespace mold {
    function split (line 38) | static std::vector<std::span<u8>> split(std::span<u8> input) {
    function zlib_compress (line 48) | static std::span<u8> zlib_compress(std::span<u8> input) {
    function zstd_compress (line 142) | static std::span<u8> zstd_compress(std::span<u8> input) {

FILE: lib/crc32.cc
  type mold (line 6) | namespace mold {
    function crc32_solve (line 13) | std::vector<u8> crc32_solve(u32 current, u32 desired) {
    function u32 (line 34) | u32 compute_crc32(u32 crc, u8 *buf, i64 len) {

FILE: lib/demangle.cc
  type mold (line 11) | namespace mold {
    function demangle_cpp (line 13) | std::optional<std::string_view> demangle_cpp(std::string_view name) {
    function demangle_rust (line 33) | std::optional<std::string_view> demangle_rust(std::string_view name) {

FILE: lib/filepath.cc
  type mold (line 14) | namespace mold {
    function get_self_path (line 17) | std::string get_self_path() {

FILE: lib/glob.cc
  type mold (line 69) | namespace mold {
    function parse_glob (line 71) | static std::vector<MultiGlob::State> parse_glob(std::string_view pat) {
    function i64 (line 202) | i64 MultiGlob::find(std::string_view str) {
    function i64 (line 242) | i64 Glob::find(std::string_view str) {

FILE: lib/hyperloglog.cc
  type mold (line 11) | namespace mold {
    function i64 (line 13) | i64 HyperLogLog::get_cardinality() const {

FILE: lib/integers.h
  function namespace (line 43) | namespace mold {
  function T (line 87) | static T bswap(T v) {

FILE: lib/lib.h
  function hash_string (line 47) | inline uint64_t hash_string(std::string_view str) {
  function class (line 51) | class HashCmp {
  function namespace (line 62) | namespace mold {
  type TimerRecord (line 112) | struct TimerRecord {
  function stop (line 143) | void stop() {
  function has_single_bit (line 156) | inline bool has_single_bit(u64 val) {
  function u64 (line 161) | inline u64 bit_ceil(u64 val) {
  function u64 (line 167) | inline u64 align_to(u64 val, u64 align) {
  function u64 (line 174) | inline u64 align_down(u64 val, u64 align) {
  function u64 (line 179) | inline u64 bit(u64 val, i64 pos) {
  function u64 (line 184) | inline u64 bits(u64 val, u64 hi, u64 lo) {
  function i64 (line 190) | inline i64 sign_extend(u64 val, i64 n) {
  function is_int (line 194) | inline bool is_int(u64 val, i64 n) {
  type alignas (line 387) | struct alignas
  function resize (line 393) | void resize(i64 nbuckets) {
  function i64 (line 458) | i64 get_idx(T *value) const {
  function class (line 531) | class HyperLogLog {
  function i64 (line 537) | i64 get_cardinality() const;
  function class (line 582) | class MultiGlob {
  function class (line 606) | class Glob {
  function std (line 624) | inline std::filesystem::path path_dirname(std::string_view path) {
  function std (line 628) | inline std::string path_filename(std::string_view path) {
  function std (line 632) | inline std::string path_clean(std::string_view path) {
  function class (line 656) | class Compressor {
  function class (line 666) | class ZlibCompressor : public Compressor {
  function class (line 675) | class ZstdCompressor : public Compressor {
  function class (line 690) | class TarWriter {

FILE: lib/perf.cc
  type mold (line 13) | namespace mold {
    function i64 (line 15) | i64 Counter::get_value() {
    function i64 (line 27) | static i64 now_nsec() {
    function get_usage (line 31) | static std::pair<i64, i64> get_usage() {
    function print_rec (line 73) | static void print_rec(TimerRecord &rec, i64 indent) {
    function print_timer_records (line 87) | void print_timer_records(

FILE: lib/random.cc
  type mold (line 5) | namespace mold {
    function get_random_bytes (line 7) | void get_random_bytes(u8 *buf, i64 size) {

FILE: lib/siphash.h
  function update (line 29) | void update(void *msgp, int64_t msglen) {
  function finish (line 59) | void finish(void *out) {
  function hash (line 74) | static void hash(void *out, void *key, void *in, int inlen) {
  function read64 (line 86) | uint64_t read64(void *loc) {
  function write64 (line 94) | void write64(void *loc, uint64_t val) {
  function bswap (line 100) | uint64_t bswap(uint64_t val) {
  function round (line 111) | void round() {
  function compress (line 128) | void compress(uint64_t m) {
  function finalize (line 135) | void finalize() {

FILE: lib/tar.cc
  type mold (line 9) | namespace mold {
    type UstarHeader (line 21) | struct UstarHeader {
    function finalize (line 43) | static void finalize(UstarHeader &hdr) {
    function encode_path (line 60) | static std::string encode_path(std::string basedir, std::string path) {

FILE: src/arch-arm32.cc
  type mold (line 41) | namespace mold {
    function i64 (line 46) | i64 get_addend(u8 *loc, const ElfRel<E> &rel) {
    function write_arm_mov (line 128) | static void write_arm_mov(u8 *loc, u32 val) {
    function write_thm_b21 (line 134) | static void write_thm_b21(u8 *loc, u32 val) {
    function write_thm_b25 (line 146) | static void write_thm_b25(u8 *loc, u32 val) {
    function write_thm_mov (line 160) | static void write_thm_mov(u8 *loc, u32 val) {
    function write_addend (line 172) | void write_addend(u8 *loc, i64 val, const ElfRel<E> &rel) {
    function write_plt_header (line 229) | void write_plt_header(Context<E> &ctx, u8 *buf) {
    function write_plt_entry (line 253) | void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function write_pltgot_entry (line 259) | void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function u64 (line 710) | u64 get_eflags(Context<E> &ctx) {
    function u64 (line 750) | static u64 get_text_end(Context<E> &ctx) {
    type Entry (line 783) | struct Entry {
    function arm32be_swap_bytes (line 871) | void arm32be_swap_bytes(Context<E> &ctx) {

FILE: src/arch-arm64.cc
  type mold (line 24) | namespace mold {
    function write_adrp (line 28) | static void write_adrp(u8 *buf, u64 val) {
    function write_adr (line 32) | static void write_adr(u8 *buf, u64 val) {
    function write_movn_movz (line 36) | static void write_movn_movz(u8 *buf, i64 val) {
    function u64 (line 45) | static u64 page(u64 val) {
    function write_plt_header (line 50) | void write_plt_header(Context<E> &ctx, u8 *buf) {
    function write_plt_entry (line 72) | void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function write_pltgot_entry (line 90) | void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function is_adrp (line 128) | static bool is_adrp(u8 *loc) {
    function is_ldr (line 134) | static bool is_ldr(u8 *loc) {
    function is_add (line 140) | static bool is_add(u8 *loc) {
    class Thunk<E> (line 663) | class Thunk<E>

FILE: src/arch-i386.cc
  type mold (line 40) | namespace mold {
    function i64 (line 45) | i64 get_addend(u8 *loc, const ElfRel<E> &rel) {
    function write_addend (line 75) | void write_addend(u8 *loc, i64 val, const ElfRel<E> &rel) {
    function write_plt_header (line 110) | void write_plt_header(Context<E> &ctx, u8 *buf) {
    function write_plt_entry (line 135) | void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function write_pltgot_entry (line 158) | void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function u32 (line 195) | static u32 relax_got32x(u8 *loc) {
    function relax_gd_to_le (line 203) | static void relax_gd_to_le(u8 *loc, ElfRel<E> rel, u64 val) {
    function relax_ld_to_le (line 226) | static void relax_ld_to_le(u8 *loc, ElfRel<E> rel, u64 tls_size) {
    function u32 (line 253) | static u32 relax_tlsdesc_to_ie(u8 *loc) {
    function u32 (line 267) | static u32 relax_tlsdesc_to_le(u8 *loc) {

FILE: src/arch-loongarch.cc
  type mold (line 28) | namespace mold {
    function u64 (line 32) | static u64 page(u64 val) {
    function u64 (line 36) | static u64 hi20(u64 val, u64 pc) {
    function u64 (line 54) | static u64 higher(u64 val, u64 pc) {
    function u64 (line 74) | static u64 higher20(u64 val, u64 pc) {
    function u64 (line 78) | static u64 highest12(u64 val, u64 pc) {
    function write_k12 (line 82) | static void write_k12(u8 *loc, u32 val) {
    function write_k16 (line 88) | static void write_k16(u8 *loc, u32 val) {
    function write_j20 (line 94) | static void write_j20(u8 *loc, u32 val) {
    function write_d5k16 (line 100) | static void write_d5k16(u8 *loc, u32 val) {
    function write_d10k16 (line 107) | static void write_d10k16(u8 *loc, u32 val) {
    function u32 (line 114) | static u32 get_rd(u32 insn) {
    function u32 (line 118) | static u32 get_rj(u32 insn) {
    function set_rj (line 122) | static void set_rj(u8 *loc, u32 rj) {
    function is_relaxable_got_load (line 133) | static bool is_relaxable_got_load(Context<E> &ctx, InputSection<E> &is...
    function shrink_section (line 856) | void shrink_section(Context<E> &ctx, InputSection<E> &isec) {

FILE: src/arch-m68k.cc
  type mold (line 21) | namespace mold {
    function write_plt_header (line 26) | void write_plt_header(Context<E> &ctx, u8 *buf) {
    function write_plt_entry (line 39) | void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function write_pltgot_entry (line 51) | void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {

FILE: src/arch-ppc32.cc
  type mold (line 47) | namespace mold {
    function u64 (line 51) | static u64 lo(u64 x)    { return x & 0xffff; }
    function u64 (line 52) | static u64 hi(u64 x)    { return x >> 16; }
    function u64 (line 53) | static u64 ha(u64 x)    { return (x + 0x8000) >> 16; }
    function u64 (line 54) | static u64 high(u64 x)  { return (x >> 16) & 0xffff; }
    function u64 (line 55) | static u64 higha(u64 x) { return ((x + 0x8000) >> 16) & 0xffff; }
    function write_plt_header (line 58) | void write_plt_header(Context<E> &ctx, u8 *buf) {
    function write_plt_entry (line 109) | void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function write_pltgot_entry (line 120) | void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {

FILE: src/arch-ppc64v1.cc
  type mold (line 55) | namespace mold {
    function u64 (line 59) | static u64 lo(u64 x)    { return x & 0xffff; }
    function u64 (line 60) | static u64 hi(u64 x)    { return x >> 16; }
    function u64 (line 61) | static u64 ha(u64 x)    { return (x + 0x8000) >> 16; }
    function u64 (line 62) | static u64 high(u64 x)  { return (x >> 16) & 0xffff; }
    function u64 (line 63) | static u64 higha(u64 x) { return ((x + 0x8000) >> 16) & 0xffff; }
    function write_plt_header (line 72) | void write_plt_header(Context<E> &ctx, u8 *buf) {
    function write_plt_entry (line 96) | void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function write_pltgot_entry (line 131) | void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {}
    type OpdSymbol (line 506) | struct OpdSymbol {
    function ppc64v1_rewrite_opd (line 561) | void ppc64v1_rewrite_opd(Context<E> &ctx) {
    function ppc64v1_scan_symbols (line 621) | void ppc64v1_scan_symbols(Context<E> &ctx) {
    function i64 (line 646) | i64 PPC64OpdSection::get_reldyn_size(Context<E> &ctx) const {

FILE: src/arch-ppc64v2.cc
  type mold (line 87) | namespace mold {
    function u64 (line 91) | static u64 lo(u64 x)    { return x & 0xffff; }
    function u64 (line 92) | static u64 hi(u64 x)    { return x >> 16; }
    function u64 (line 93) | static u64 ha(u64 x)    { return (x + 0x8000) >> 16; }
    function u64 (line 94) | static u64 high(u64 x)  { return (x >> 16) & 0xffff; }
    function u64 (line 95) | static u64 higha(u64 x) { return ((x + 0x8000) >> 16) & 0xffff; }
    function write34 (line 97) | static void write34(u8 *loc, u64 x) {
    function write_plt_header (line 110) | void write_plt_header(Context<E> &ctx, u8 *buf) {
    function write_plt_entry (line 142) | void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function write_pltgot_entry (line 152) | void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {}
    function u64 (line 176) | static u64 get_local_entry_offset(Context<E> &ctx, Symbol<E> &sym) {
    function u64 (line 676) | u64 get_eflags(Context<E> &ctx) {

FILE: src/arch-riscv.cc
  type mold (line 26) | namespace mold {
    function write_itype (line 30) | static void write_itype(u8 *loc, u32 val) {
    function write_stype (line 35) | static void write_stype(u8 *loc, u32 val) {
    function write_btype (line 40) | static void write_btype(u8 *loc, u32 val) {
    function write_utype (line 46) | static void write_utype(u8 *loc, u32 val) {
    function write_jtype (line 57) | static void write_jtype(u8 *loc, u32 val) {
    function write_citype (line 63) | static void write_citype(u8 *loc, u32 val) {
    function write_cbtype (line 68) | static void write_cbtype(u8 *loc, u32 val) {
    function write_cjtype (line 75) | static void write_cjtype(u8 *loc, u32 val) {
    function set_rs1 (line 83) | static void set_rs1(u8 *loc, u32 rs1) {
    function u32 (line 89) | static u32 get_rd(u8 *loc) {
    function is_got_load_pair (line 253) | static bool is_got_load_pair(Context<E> &ctx, InputSection<E> &isec,
    function u64 (line 815) | u64 get_eflags(Context<E> &ctx) {
    function shrink_section (line 841) | void shrink_section(Context<E> &ctx, InputSection<E> &isec) {
    type Extn (line 1027) | struct Extn {
    function extn_name_less (line 1041) | static bool extn_name_less(std::string_view x, std::string_view y) {
    function parse_arch_string (line 1066) | static std::vector<Extn> parse_arch_string(std::string_view str) {
    function merge_extensions (line 1085) | static std::vector<Extn> merge_extensions(std::span<Extn> x, std::span...
    function to_string (line 1115) | static std::string to_string(std::span<Extn> v) {

FILE: src/arch-s390x.cc
  type mold (line 42) | namespace mold {
    function write_mid20 (line 46) | static void write_mid20(u8 *loc, u64 val) {
    function write_plt_header (line 51) | void write_plt_header(Context<E> &ctx, u8 *buf) {
    function write_plt_entry (line 79) | void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function write_pltgot_entry (line 92) | void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {

FILE: src/arch-sh4.cc
  type mold (line 65) | namespace mold {
    function i64 (line 72) | i64 get_addend(u8 *loc, const ElfRel<E> &rel) {
    function write_addend (line 96) | void write_addend(u8 *loc, i64 val, const ElfRel<E> &rel) {
    function write_plt_header (line 118) | void write_plt_header(Context<E> &ctx, u8 *buf) {
    function write_plt_entry (line 151) | void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function write_pltgot_entry (line 184) | void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {

FILE: src/arch-sparc64.cc
  type mold (line 60) | namespace mold {
    function write_plt_header (line 77) | void write_plt_header(Context<E> &ctx, u8 *buf) {
    function write_plt_entry (line 82) | void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function write_pltgot_entry (line 104) | void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {

FILE: src/arch-x86-64.cc
  type mold (line 33) | namespace mold {
    function write_plt_header (line 50) | void write_plt_header(Context<E> &ctx, u8 *buf) {
    function write_plt_entry (line 68) | void write_plt_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function write_pltgot_entry (line 96) | void write_pltgot_entry(Context<E> &ctx, u8 *buf, Symbol<E> &sym) {
    function u32 (line 131) | static u32 relax_gotpcrelx(u8 *loc, const ElfRel<E> &rel) {
    function u32 (line 162) | static u32 relax_gottpoff(u8 *loc, const ElfRel<E> &rel) {
    function u32 (line 206) | static u32 relax_tlsdesc_to_ie(u8 *loc, const ElfRel<E> &rel) {
    function u32 (line 250) | static u32 relax_tlsdesc_to_le(u8 *loc, const ElfRel<E> &rel) {
    function relax_gd_to_le (line 297) | static void relax_gd_to_le(u8 *loc, const ElfRel<E> &rel, u64 val) {
    function relax_gd_to_ie (line 341) | static void relax_gd_to_ie(u8 *loc, const ElfRel<E> &rel, u64 val) {
    function relax_ld_to_le (line 374) | static void relax_ld_to_le(u8 *loc, const ElfRel<E> &rel, i64 tls_size) {
    function rewrite_endbr (line 881) | void rewrite_endbr(Context<E> &ctx) {

FILE: src/archive-file.cc
  type mold (line 28) | namespace mold {
    type ArHdr (line 31) | struct ArHdr {
      method starts_with (line 40) | bool starts_with(std::string_view s) const {
      method is_strtab (line 44) | bool is_strtab() const {
      method is_symtab (line 48) | bool is_symtab() const {
      method read_name (line 52) | std::string read_name(std::string_view strtab, u8 *&ptr) const {
    function read_thin_archive_members (line 79) | std::vector<MappedFile *>
    function read_fat_archive_members (line 127) | std::vector<MappedFile *>
    function read_archive_members (line 166) | std::vector<MappedFile *>

FILE: src/cmdline.cc
  type mold (line 25) | namespace mold {
    function read_response_file (line 251) | static std::vector<std::string_view>
    function expand_response_files (line 350) | std::vector<std::string_view>
    function string_trim (line 362) | static std::string_view string_trim(std::string_view str) {
    function add_dashes (line 374) | static std::vector<std::string> add_dashes(std::string name) {
    function i64 (line 390) | static i64 parse_hex(Context<E> &ctx, std::string opt, std::string_vie...
    function i64 (line 401) | static i64 parse_number(Context<E> &ctx, std::string opt,
    function from_hex (line 418) | static char from_hex(char c) {
    function parse_hex_build_id (line 428) | static std::vector<u8> parse_hex_build_id(Context<E> &ctx, std::string...
    function parse_package_metadata (line 442) | static std::string
    function split_string (line 463) | static std::vector<std::string_view>
    function read_retain_symbols_file (line 480) | static void read_retain_symbols_file(Context<E> &ctx, std::string_view...
    function is_file (line 505) | static bool is_file(const std::filesystem::path& path) {
    function parse_section_order (line 511) | static std::vector<SectionOrder>
    function parse_defsym_value (line 568) | static std::variant<Symbol<E> *, u64>
    function parse_kernel_version (line 584) | static std::tuple<int, int, int>
    function returns_etxtbsy (line 599) | static bool returns_etxtbsy() {
    function parse_nonpositional_args (line 611) | std::vector<std::string> parse_nonpositional_args(Context<E> &ctx) {

FILE: src/elf.cc
  type mold (line 4) | namespace mold {
    function unknown_type (line 6) | static std::string unknown_type(u32 r_type) {

FILE: src/elf.h
  function namespace (line 10) | namespace mold {
  function E (line 1737) | struct ElfChdr<E> {
  function SPARC64 (line 1763) | struct ElfRel<SPARC64> {
  function SH4LE (line 1777) | struct ElfRel<SH4LE> {
  function SH4BE (line 1793) | struct ElfRel<SH4BE> {
  type I386 (line 1871) | struct I386 {
  type ARM64LE (line 1896) | struct ARM64LE {
  function ARM64LE (line 1923) | struct ARM64BE : ARM64LE {
  type ARM32LE (line 1928) | struct ARM32LE {
  function ARM32LE (line 1958) | struct ARM32BE : ARM32LE {
  type RV64LE (line 1963) | struct RV64LE {
  function RV64LE (line 1988) | struct RV64BE : RV64LE {
  type RV32LE (line 1993) | struct RV32LE {
  function RV32LE (line 2018) | struct RV32BE : RV32LE {
  type PPC32 (line 2023) | struct PPC32 {
  type PPC64 (line 2052) | struct PPC64 {
  function PPC64 (line 2070) | struct PPC64V1 : PPC64 {
  function PPC64 (line 2080) | struct PPC64V2 : PPC64 {
  type S390X (line 2091) | struct S390X {
  type SPARC64 (line 2115) | struct SPARC64 {
  type M68K (line 2139) | struct M68K {
  type SH4LE (line 2162) | struct SH4LE {
  function SH4LE (line 2185) | struct SH4BE : SH4LE {
  type LOONGARCH64 (line 2191) | struct LOONGARCH64 {
  type LOONGARCH32 (line 2216) | struct LOONGARCH32 {

FILE: src/entry.cc
  function main (line 24) | int main(int argc, char **argv) {

FILE: src/error.cc
  type mold (line 3) | namespace mold {
    class Fatal<E> (line 51) | class Fatal<E>
    class Error<E> (line 52) | class Error<E>
    class Warn<E> (line 53) | class Warn<E>

FILE: src/filetype.cc
  type mold (line 3) | namespace mold {
    function is_text_file (line 5) | static bool is_text_file(MappedFile *mf) {
    function is_gcc_lto_obj (line 16) | static bool is_gcc_lto_obj(MappedFile *mf, bool has_plugin) {
    function FileType (line 69) | FileType get_file_type(Context<E> &ctx, MappedFile *mf) {
    function get_elf_type (line 128) | static std::string_view get_elf_type(u8 *buf) {
    function get_machine_type (line 170) | std::string_view

FILE: src/gc-sections.cc
  type mold (line 11) | namespace mold {
    function should_keep (line 14) | static bool should_keep(const InputSection<E> &isec) {
    function mark_section (line 36) | static bool mark_section(InputSection<E> *isec) {
    function collect_root_set (line 41) | static tbb::concurrent_vector<InputSection<E> *>
    function visit (line 100) | static void visit(Context<E> &ctx, InputSection<E> *isec,
    function mark (line 138) | static void mark(Context<E> &ctx,
    function sweep (line 150) | static void sweep(Context<E> &ctx) {
    function gc_sections (line 190) | void gc_sections(Context<E> &ctx) {

FILE: src/gdb-index.cc
  type mold (line 62) | namespace mold {
    type DwarfKind (line 64) | enum DwarfKind { DWARF2_32, DWARF5_32, DWARF2_64, DWARF5_64 }
    type CuHdrDwarf2_32 (line 67) | struct CuHdrDwarf2_32 {
    type CuHdrDwarf5_32 (line 75) | struct CuHdrDwarf5_32 {
    type CuHdrDwarf2_64 (line 84) | struct CuHdrDwarf2_64 {
    type CuHdrDwarf5_64 (line 93) | struct CuHdrDwarf5_64 {
    type PubnamesHdr32 (line 103) | struct PubnamesHdr32 {
    type PubnamesHdr64 (line 111) | struct PubnamesHdr64 {
    type SectionHeader (line 119) | struct SectionHeader {
    type NameType (line 128) | struct NameType {
    type MapValue (line 135) | struct MapValue {
    type Compunit (line 142) | struct Compunit {
    function u32 (line 152) | static u32 gdb_hash(std::string_view name) {
    function DwarfKind (line 163) | static DwarfKind get_dwarf_kind(Context<E> &ctx, u8 *p) {
    function u8 (line 180) | u8 *find_cu_abbrev(Context<E> &ctx, u8 **p, const CuHdr &hdr) {
    function u64 (line 242) | u64 read_scalar(Context<E> &ctx, u8 **p, u64 form) {
    function read_debug_range (line 311) | static std::vector<std::pair<u64, u64>>
    function read_rnglist_range (line 326) | static void
    function read_address_ranges (line 389) | static std::vector<std::pair<u64, u64>>
    function i64 (line 511) | static i64 read_pubnames_cu(Context<E> &ctx, const PubnamesHdr &hdr,
    function read_pubnames (line 550) | static void read_pubnames(Context<E> &ctx, std::vector<Compunit> &cus,
    function read_compunits (line 573) | static std::vector<Compunit> read_compunits(Context<E> &ctx) {
    function get_buffer (line 631) | std::span<u8> get_buffer(Context<E> &ctx, Chunk<E> *chunk) {
    function write_gdb_index (line 640) | void write_gdb_index(Context<E> &ctx) {

FILE: src/icf.cc
  type std (line 84) | namespace std {
    type hash<Digest> (line 85) | struct hash<Digest> {
  type mold (line 95) | namespace mold {
    function uniquify_cies (line 100) | static void uniquify_cies(Context<E> &ctx) {
    function is_eligible (line 124) | static bool is_eligible(Context<E> &ctx, InputSection<E> &isec) {
    function is_leaf (line 149) | static bool is_leaf(Context<E> &ctx, InputSection<E> &isec) {
    type LeafHasher (line 161) | struct LeafHasher {
    type LeafEq (line 173) | struct LeafEq {
    function merge_leaf_nodes (line 195) | static void merge_leaf_nodes(Context<E> &ctx) {
    function Digest (line 243) | static Digest compute_digest(Context<E> &ctx, InputSection<E> &isec) {
    function gather_sections (line 314) | static std::vector<InputSection<E> *> gather_sections(Context<E> &ctx) {
    function compute_digests (line 349) | static std::vector<Digest>
    function gather_edges (line 364) | static void gather_edges(Context<E> &ctx,
    function i64 (line 409) | static i64 propagate(std::span<std::vector<Digest>> digests,
    function i64 (line 448) | static i64 count_num_classes(std::span<Digest> digests,
    function print_icf_sections (line 462) | static void print_icf_sections(Context<E> &ctx) {
    function icf_sections (line 511) | void icf_sections(Context<E> &ctx) {

FILE: src/input-files.cc
  type mold (line 11) | namespace mold {
    function is_rust_symbol (line 31) | static bool is_rust_symbol(const Symbol<E> &sym) {
    function demangle (line 44) | std::string_view demangle(const Symbol<E> &sym) {
    function is_debug_section (line 114) | static bool is_debug_section(const ElfShdr<E> &shdr, std::string_view ...
    function read_riscv_attributes (line 159) | static void read_riscv_attributes(Context<E> &ctx, ObjectFile<E> &file,
    function is_known_section_type (line 208) | static bool is_known_section_type(const ElfShdr<E> &shdr) {
    function decode_crel (line 239) | std::vector<ElfRel<E>> decode_crel(Context<E> &ctx, ObjectFile<E> &file,
    function ComdatGroup (line 286) | ComdatGroup *insert_comdat_group(Context<E> &ctx, std::string_view nam...
    function u64 (line 919) | static u64 get_rank(InputFile<E> *file, const ElfSym<E> &esym, bool is...
    function u64 (line 938) | static u64 get_rank(const Symbol<E> &sym) {
    function print_trace_symbol (line 974) | static void print_trace_symbol(Context<E> &ctx, InputFile<E> &file,
    function should_write_to_local_symtab (line 1132) | static bool should_write_to_local_symtab(Context<E> &ctx, Symbol<E> &s...
    function i64 (line 1502) | i64 SharedFile<E>::get_alignment(Symbol<E> *sym) {
    class InputFile<E> (line 1567) | class InputFile<E>
    class ObjectFile<E> (line 1568) | class ObjectFile<E>
    class SharedFile<E> (line 1569) | class SharedFile<E>

FILE: src/input-sections.cc
  type mold (line 6) | namespace mold {
    function i64 (line 8) | static i64 to_p2align(u64 alignment) {
    function cie_equals (line 15) | bool cie_equals(const CieRecord<E> &a, const CieRecord<E> &b) {
    type u8 (line 124) | enum : u8 { NONE, ERROR, COPYREL, PLT, CPLT }
    function do_action (line 127) | static void do_action(Context<E> &ctx, Action action, InputSection<E> ...
    function i64 (line 152) | static inline i64 get_output_type(Context<E> &ctx) {
    function i64 (line 161) | static inline i64 get_sym_type(Symbol<E> &sym) {
    function find_null (line 363) | static size_t find_null(std::string_view data, i64 pos, i64 entsize) {
    class InputSection<E> (line 448) | class InputSection<E>
    class MergeableSection<E> (line 449) | class MergeableSection<E>

FILE: src/jobs-unix.cc
  type mold (line 21) | namespace mold {
    function acquire_global_lock (line 25) | void acquire_global_lock() {
    function release_global_lock (line 45) | void release_global_lock() {

FILE: src/jobs-win32.cc
  type mold (line 1) | namespace mold {
    function acquire_global_lock (line 3) | void acquire_global_lock() {}
    function release_global_lock (line 4) | void release_global_lock() {}

FILE: src/linker-script.cc
  type mold (line 10) | namespace mold {
    function get_line (line 12) | static std::string_view get_line(std::string_view input, const char *p...
    function unquote (line 106) | static std::string_view unquote(std::string_view s) {
    function is_in_sysroot (line 126) | static bool is_in_sysroot(Context<E> &ctx, std::string path) {
    function MappedFile (line 136) | MappedFile *Script<E>::resolve_path(std::string_view tok, bool check_t...
    function read_label (line 258) | static bool read_label(std::span<std::string_view> &tok, std::string l...
    function parse_dynamic_list (line 412) | std::vector<DynamicPattern>
    class Script<E> (line 421) | class Script<E>

FILE: src/lto-unix.cc
  type mold (line 98) | namespace mold {
    function PluginStatus (line 117) | static PluginStatus message(PluginLevel level, const char *fmt, ...) {
    function PluginStatus (line 143) | static PluginStatus register_claim_file_hook(ClaimFileHandler fn) {
    function PluginStatus (line 150) | static PluginStatus
    function PluginStatus (line 158) | static PluginStatus register_cleanup_hook(CleanupHandler fn) {
    function PluginStatus (line 164) | static PluginStatus
    function PluginStatus (line 173) | static PluginStatus add_input_file(const char *path) {
    function PluginStatus (line 193) | static PluginStatus
    function PluginStatus (line 200) | static PluginStatus release_input_file(const void *handle) {
    function PluginStatus (line 208) | static PluginStatus add_input_library(const char *path) {
    function PluginStatus (line 213) | static PluginStatus set_extra_library_path(const char *path) {
    function PluginStatus (line 219) | static PluginStatus get_view(const void *handle, const void **view) {
    function PluginStatus (line 227) | static PluginStatus
    function PluginStatus (line 233) | static PluginStatus
    function PluginStatus (line 239) | static PluginStatus
    function PluginStatus (line 246) | static PluginStatus
    function PluginStatus (line 254) | static PluginStatus
    function PluginStatus (line 261) | static PluginStatus allow_section_ordering() {
    function PluginStatus (line 266) | static PluginStatus
    function PluginStatus (line 280) | static PluginStatus
    function restart_process (line 339) | static void restart_process(Context<E> &ctx) {
    function PluginStatus (line 363) | static PluginStatus
    function PluginStatus (line 370) | static PluginStatus
    function PluginStatus (line 376) | static PluginStatus allow_unique_segment_for_sections() {
    function PluginStatus (line 381) | static PluginStatus
    function PluginStatus (line 391) | static PluginStatus
    function PluginStatus (line 398) | static PluginStatus
    function PluginStatus (line 405) | static PluginStatus
    function PluginStatus (line 411) | static PluginStatus
    function PluginLinkerAPIVersion (line 418) | static PluginLinkerAPIVersion
    function load_lto_plugin (line 442) | static void load_lto_plugin(Context<E> &ctx) {
    function to_elf_sym (line 514) | static ElfSym<E> to_elf_sym(PluginSymbol &psym) {
    function is_llvm (line 566) | static bool is_llvm(Context<E> &ctx) {
    function supports_v3_api (line 573) | static bool supports_v3_api(Context<E> &ctx) {
    function PluginInputFile (line 578) | static PluginInputFile
    function run_lto_plugin (line 681) | std::vector<ObjectFile<E> *> run_lto_plugin(Context<E> &ctx) {
    function lto_cleanup (line 741) | void lto_cleanup(Context<E> &ctx) {

FILE: src/lto-win32.cc
  type mold (line 4) | namespace mold {
    function run_lto_plugin (line 12) | std::vector<ObjectFile<E> *> run_lto_plugin(Context<E> &ctx) {
    function lto_cleanup (line 17) | void lto_cleanup(Context<E> &ctx) {}

FILE: src/lto.h
  function namespace (line 5) | namespace mold {

FILE: src/main.cc
  type mold (line 10) | namespace mold {
    function check_file_compatibility (line 13) | static void
    function read_file (line 78) | void read_file(Context<E> &ctx, ReaderContext &rctx, MappedFile *mf) {
    function detect_machine_type (line 121) | static std::string_view
    function MappedFile (line 156) | MappedFile *open_library(Context<E> &ctx, ReaderContext &rctx, std::st...
    function MappedFile (line 171) | MappedFile *find_library(Context<E> &ctx, ReaderContext &rctx, std::st...
    function read_input_files (line 193) | static void read_input_files(Context<E> &ctx, std::span<std::string> a...
    function has_lto_obj (line 256) | static bool has_lto_obj(Context<E> &ctx) {
    function i64 (line 264) | static i64 get_thread_count(Context<E> &ctx) {
    function mold_main (line 275) | int mold_main(int argc, char **argv) {

FILE: src/mapfile.cc
  type mold (line 10) | namespace mold {
    function get_map (line 17) | static Map<E> get_map(Context<E> &ctx) {
    function print_map (line 43) | void print_map(Context<E> &ctx) {

FILE: src/mapped-file-unix.cc
  type mold (line 3) | namespace mold {
    function MappedFile (line 5) | MappedFile *open_file_impl(const std::string &path, std::string &error) {

FILE: src/mapped-file-win32.cc
  type mold (line 3) | namespace mold {
    function MappedFile (line 5) | MappedFile *open_file_impl(const std::string &path, std::string &error) {

FILE: src/mold-wrapper.c
  function debug_print (line 26) | static void debug_print(const char *fmt, ...) {
  function count_args (line 38) | static int count_args(va_list *ap) {
  function copy_args (line 49) | static void copy_args(char **argv, const char *arg0, va_list *ap) {
  function is_ld (line 59) | static bool is_ld(const char *path) {
  function execvpe (line 69) | int execvpe(const char *file, char *const *argv, char *const *envp) {
  function execve (line 82) | int execve(const char *path, char *const *argv, char *const *envp) {
  function execl (line 90) | int execl(const char *path, const char *arg0, ...) {
  function execlp (line 99) | int execlp(const char *file, const char *arg0, ...) {
  function execle (line 108) | int execle(const char *path, const char *arg0, ...) {
  function execv (line 118) | int execv(const char *path, char *const *argv) {
  function execvp (line 122) | int execvp(const char *file, char *const *argv) {
  function posix_spawn (line 126) | int posix_spawn(pid_t *pid, const char *path,
  function posix_spawnp (line 137) | int posix_spawnp(pid_t *pid, const char *file,

FILE: src/mold.h
  function namespace (line 39) | namespace mold {
  function PPC32 (line 2287) | struct ContextExtras<PPC32> {
  function PPC64V1 (line 2292) | struct ContextExtras<PPC64V1> {
  function PPC64V2 (line 2298) | struct ContextExtras<PPC64V2> {
  function SPARC64 (line 2305) | struct ContextExtras<SPARC64> {
  function checkpoint (line 2326) | void checkpoint() {
  function has_got (line 2687) | bool has_got(Context<E> &ctx) const { return get_got_idx(ctx) != -1; }
  function has_gottp (line 2688) | bool has_gottp(Context<E> &ctx) const { return get_gottp_idx(ctx) != -1; }
  function has_tlsgd (line 2689) | bool has_tlsgd(Context<E> &ctx) const { return get_tlsgd_idx(ctx) != -1; }
  function has_tlsdesc (line 2690) | bool has_tlsdesc(Context<E> &ctx) const { return get_tlsdesc_idx(ctx) !=...
  function has_opd (line 2691) | bool has_opd(Context<E> &ctx) const { return get_opd_idx(ctx) != -1; }
  function is_remaining_undef_weak (line 2704) | bool is_remaining_undef_weak() const;
  function is_c_identifier (line 3586) | inline bool is_c_identifier(std::string_view s) {

FILE: src/output-chunks.cc
  type mold (line 11) | namespace mold {
    function u32 (line 14) | static u32 elf_hash(std::string_view name) {
    function u64 (line 43) | static u64 get_entry_addr(Context<E> &ctx) {
    function i64 (line 123) | i64 to_phdr_flags(Context<E> &ctx, Chunk<E> *chunk) {
    function create_phdr (line 147) | static std::vector<ElfPhdr<E>> create_phdr(Context<E> &ctx) {
    function i64 (line 493) | i64 DynstrSection<E>::add_string(std::string_view str) {
    function i64 (line 506) | i64 DynstrSection<E>::find_string(std::string_view str) {
    function contains_variant_pcs (line 620) | static bool contains_variant_pcs(Context<E> &ctx) {
    function contains_variant_cc (line 629) | static bool contains_variant_cc(Context<E> &ctx) {
    function create_dynamic_section (line 637) | static std::vector<Word<E>> create_dynamic_section(Context<E> &ctx) {
    type Group (line 850) | struct Group {
    function encode_relr (line 1012) | static std::vector<u64> encode_relr(std::span<u64> pos) {
    function AbsRelKind (line 1041) | static AbsRelKind get_abs_rel_kind(Context<E> &ctx, Symbol<E> &sym) {
    function is_absrel (line 1056) | static bool is_absrel(const ElfRel<E> &r) {
    function i64 (line 1127) | i64 OutputSection<E>::get_reldyn_size(Context<E> &ctx) const {
    function u64 (line 1264) | u64 GotSection<E>::get_tlsld_addr(Context<E> &ctx) const {
    type GotEntry (line 1271) | struct GotEntry {
      method is_relr (line 1272) | bool is_relr(Context<E> &ctx) const {
    function get_got_entries (line 1299) | static std::vector<GotEntry<E>> get_got_entries(Context<E> &ctx) {
    function i64 (line 1398) | i64 GotSection<E>::get_reldyn_size(Context<E> &ctx) const {
    function u64 (line 1729) | static u64 get_symbol_size(Symbol<E> &sym) {
    function to_output_esym (line 1741) | std::optional<ElfSym<E>>
    function get_merged_output_name (line 2003) | std::string_view
    function get_cmdline_args (line 2102) | static std::string get_cmdline_args(Context<E> &ctx) {
    function add_comment_strings (line 2112) | static void add_comment_strings(Context<E> &ctx) {
    type HdrEntry (line 2306) | struct HdrEntry {
    function is_glibc2 (line 2565) | static bool is_glibc2(SharedFile<E> &file) {
    class Chunk<E> (line 3025) | class Chunk<E>
    class OutputEhdr<E> (line 3026) | class OutputEhdr<E>
    class OutputShdr<E> (line 3027) | class OutputShdr<E>
    class OutputPhdr<E> (line 3028) | class OutputPhdr<E>
    class InterpSection<E> (line 3029) | class InterpSection<E>
    class OutputSection<E> (line 3030) | class OutputSection<E>
    class GotSection<E> (line 3031) | class GotSection<E>
    class GotPltSection<E> (line 3032) | class GotPltSection<E>
    class PltSection<E> (line 3033) | class PltSection<E>
    class PltGotSection<E> (line 3034) | class PltGotSection<E>
    class RelPltSection<E> (line 3035) | class RelPltSection<E>
    class RelDynSection<E> (line 3036) | class RelDynSection<E>
    class RelrDynSection<E> (line 3037) | class RelrDynSection<E>
    class StrtabSection<E> (line 3038) | class StrtabSection<E>
    class ShstrtabSection<E> (line 3039) | class ShstrtabSection<E>
    class DynstrSection<E> (line 3040) | class DynstrSection<E>
    class DynamicSection<E> (line 3041) | class DynamicSection<E>
    class SymtabSection<E> (line 3042) | class SymtabSection<E>
    class DynsymSection<E> (line 3043) | class DynsymSection<E>
    class HashSection<E> (line 3044) | class HashSection<E>
    class GnuHashSection<E> (line 3045) | class GnuHashSection<E>
    class MergedSection<E> (line 3046) | class MergedSection<E>
    class EhFrameSection<E> (line 3047) | class EhFrameSection<E>
    class EhFrameHdrSection<E> (line 3048) | class EhFrameHdrSection<E>
    class EhFrameRelocSection<E> (line 3049) | class EhFrameRelocSection<E>
    class CopyrelSection<E> (line 3050) | class CopyrelSection<E>
    class VersymSection<E> (line 3051) | class VersymSection<E>
    class VerneedSection<E> (line 3052) | class VerneedSection<E>
    class VerdefSection<E> (line 3053) | class VerdefSection<E>
    class BuildIdSection<E> (line 3054) | class BuildIdSection<E>
    class NotePackageSection<E> (line 3055) | class NotePackageSection<E>
    class NotePropertySection<E> (line 3056) | class NotePropertySection<E>
    class GdbIndexSection<E> (line 3057) | class GdbIndexSection<E>
    class CompressedSection<E> (line 3058) | class CompressedSection<E>
    class RelocSection<E> (line 3059) | class RelocSection<E>
    class ComdatGroupSection<E> (line 3060) | class ComdatGroupSection<E>
    class GnuDebuglinkSection<E> (line 3061) | class GnuDebuglinkSection<E>

FILE: src/output-file-unix.cc
  type mold (line 14) | namespace mold {
    function u32 (line 16) | static u32 get_umask() {
    function open_or_create_file (line 23) | static int
    class MemoryMappedOutputFile (line 43) | class MemoryMappedOutputFile : public OutputFile<E> {
      method MemoryMappedOutputFile (line 45) | MemoryMappedOutputFile(Context<E> &ctx, std::string path, i64 filesi...
      method close (line 83) | void close(Context<E> &ctx) override {
    class OutputFile<E> (line 200) | class OutputFile<E>
    class LockingOutputFile<E> (line 201) | class LockingOutputFile<E>

FILE: src/output-file-win32.cc
  type mold (line 6) | namespace mold {
    class MemoryMappedOutputFile (line 9) | class MemoryMappedOutputFile : public OutputFile<E> {
      method MemoryMappedOutputFile (line 11) | MemoryMappedOutputFile(Context<E> &ctx, std::string path, i64 filesi...
      method close (line 42) | void close(Context<E> &ctx) override {
    class OutputFile<E> (line 114) | class OutputFile<E>
    class LockingOutputFile<E> (line 115) | class LockingOutputFile<E>

FILE: src/passes.cc
  type mold (line 15) | namespace mold {
    function redo_main (line 21) | int redo_main(std::string_view target, int argc, char **argv) {
    function apply_exclude_libs (line 86) | void apply_exclude_libs(Context<E> &ctx) {
    function has_debug_info_section (line 98) | static bool has_debug_info_section(Context<E> &ctx) {
    function create_synthetic_sections (line 106) | void create_synthetic_sections(Context<E> &ctx) {
    function mark_live_objects (line 214) | static void mark_live_objects(Context<E> &ctx) {
    function resolve_default_symver (line 270) | static void resolve_default_symver(Context<E> &ctx) {
    function clear_symbols (line 284) | static void clear_symbols(Context<E> &ctx) {
    function resolve_symbols (line 306) | void resolve_symbols(Context<E> &ctx) {
    function do_lto (line 391) | void do_lto(Context<E> &ctx) {
    function parse_eh_frame_sections (line 425) | void parse_eh_frame_sections(Context<E> &ctx) {
    function create_merged_sections (line 434) | void create_merged_sections(Context<E> &ctx) {
    function convert_common_symbols (line 454) | void convert_common_symbols(Context<E> &ctx) {
    function has_ctors_and_init_array (line 463) | static bool has_ctors_and_init_array(Context<E> &ctx) {
    function u64 (line 470) | static u64 canonicalize_type(std::string_view name, u64 type) {
    type OutputSectionKey (line 492) | struct OutputSectionKey {
      type Hash (line 497) | struct Hash {
    function get_output_name (line 505) | static std::string_view
    function OutputSectionKey (line 551) | static OutputSectionKey
      type Hash (line 497) | struct Hash {
    function is_relro (line 577) | static bool is_relro(OutputSection<E> &osec) {
    function create_output_sections (line 607) | void create_output_sections(Context<E> &ctx) {
    function create_internal_file (line 725) | void create_internal_file(Context<E> &ctx) {
    function get_start_stop_name (line 770) | static std::optional<std::string>
    function add_synthetic_symbols (line 797) | void add_synthetic_symbols(Context<E> &ctx) {
    function apply_section_align (line 929) | void apply_section_align(Context<E> &ctx) {
    function check_cet_errors (line 939) | void check_cet_errors(Context<E> &ctx) {
    function print_dependencies (line 975) | void print_dependencies(Context<E> &ctx) {
    function create_response_file (line 1031) | static std::string create_response_file(Context<E> &ctx) {
    function write_repro_file (line 1055) | void write_repro_file(Context<E> &ctx) {
    function check_duplicate_symbols (line 1082) | void check_duplicate_symbols(Context<E> &ctx) {
    function convert_zero_to_bss (line 1130) | void convert_zero_to_bss(Context<E> &ctx) {
    function check_shlib_undefined (line 1162) | void check_shlib_undefined(Context<E> &ctx) {
    function check_symbol_types (line 1220) | void check_symbol_types(Context<E> &ctx) {
    function i64 (line 1265) | static i64 get_init_fini_priority(InputSection<E> *isec) {
    function i64 (line 1275) | static i64 get_ctor_dtor_priority(InputSection<E> *isec) {
    function sort_init_fini (line 1297) | void sort_init_fini(Context<E> &ctx) {
    function sort_ctor_dtor (line 1331) | void sort_ctor_dtor(Context<E> &ctx) {
    function is_dwarf32 (line 1360) | static bool is_dwarf32(Context<E> &ctx, InputSection<E> *isec) {
    function sort_debug_info_sections (line 1432) | void sort_debug_info_sections(Context<E> &ctx) {
    function fixup_ctors_in_init_array (line 1504) | void fixup_ctors_in_init_array(Context<E> &ctx) {
    function shuffle (line 1535) | static void shuffle(std::vector<InputSection<E> *> &vec, u64 seed) {
    function shuffle_sections (line 1561) | void shuffle_sections(Context<E> &ctx) {
    function add_dynamic_strings (line 1598) | void add_dynamic_strings(Context<E> &ctx) {
    function compute_section_sizes (line 1627) | void compute_section_sizes(Context<E> &ctx) {
    function claim_unresolved_symbols (line 1659) | void claim_unresolved_symbols(Context<E> &ctx) {
    function scan_relocations (line 1739) | void scan_relocations(Context<E> &ctx) {
    function compute_imported_symbol_weakness (line 1838) | void compute_imported_symbol_weakness(Context<E> &ctx) {
    function report_undef_errors (line 1856) | void report_undef_errors(Context<E> &ctx) {
    function create_reloc_sections (line 1891) | void create_reloc_sections(Context<E> &ctx) {
    function copy_chunks (line 1908) | void copy_chunks(Context<E> &ctx) {
    function construct_relr (line 1962) | void construct_relr(Context<E> &ctx) {
    function u32 (line 1971) | static u32 djb_hash(std::string_view name) {
    function sort_dynsyms (line 1979) | void sort_dynsyms(Context<E> &ctx) {
    function create_output_symtab (line 2031) | void create_output_symtab(Context<E> &ctx) {
    function apply_version_script (line 2056) | void apply_version_script(Context<E> &ctx) {
    function parse_symbol_version (line 2133) | void parse_symbol_version(Context<E> &ctx) {
    function should_export (line 2191) | static bool should_export(Context<E> &ctx, Symbol<E> &sym) {
    function is_protected (line 2211) | static bool is_protected(Context<E> &ctx, Symbol<E> &sym) {
    function compute_import_export (line 2232) | void compute_import_export(Context<E> &ctx) {
    function compute_address_significance (line 2371) | void compute_address_significance(Context<E> &ctx) {
    function sort_output_sections_regular (line 2480) | void sort_output_sections_regular(Context<E> &ctx) {
    function get_section_order_group (line 2546) | static std::string_view get_section_order_group(Chunk<E> &chunk) {
    function sort_output_sections_by_order (line 2558) | void sort_output_sections_by_order(Context<E> &ctx) {
    function sort_output_sections (line 2599) | void sort_output_sections(Context<E> &ctx) {
    function i64 (line 2607) | static i64 get_tls_segment_alignment(Context<E> &ctx) {
    function set_virtual_addresses_regular (line 2645) | static void set_virtual_addresses_regular(Context<E> &ctx) {
    function set_virtual_addresses_by_order (line 2757) | static void set_virtual_addresses_by_order(Context<E> &ctx) {
    function u64 (line 2824) | static u64 align_with_skew(u64 val, u64 align, u64 skew) {
    function i64 (line 2830) | static i64 set_file_offsets(Context<E> &ctx) {
    function separate_debug_sections (line 2900) | void separate_debug_sections(Context<E> &ctx) {
    function compute_section_headers (line 2915) | void compute_section_headers(Context<E> &ctx) {
    function i64 (line 2957) | i64 set_osec_offsets(Context<E> &ctx) {
    function i64 (line 2983) | static i64 get_num_irelative_relocs(Context<E> &ctx) {
    function u64 (line 2992) | static u64 to_paddr(Context<E> &ctx, u64 vaddr) {
    function fix_synthetic_symbols (line 3001) | void fix_synthetic_symbols(Context<E> &ctx) {
    function compress_debug_sections (line 3204) | void compress_debug_sections(Context<E> &ctx) {
    function blake3_hash (line 3233) | static void blake3_hash(u8 *buf, i64 size, u8 *out) {
    function get_shards (line 3241) | std::vector<std::span<u8>> get_shards(Context<E> &ctx) {
    function sort_reldyn (line 3270) | void sort_reldyn(Context<E> &ctx) {
    function write_build_id (line 3295) | void write_build_id(Context<E> &ctx) {
    function write_gnu_debuglink (line 3359) | void write_gnu_debuglink(Context<E> &ctx) {
    function write_separate_debug_file (line 3383) | void write_separate_debug_file(Context<E> &ctx) {
    function write_dependency_file (line 3485) | void write_dependency_file(Context<E> &ctx) {
    function show_stats (line 3516) | void show_stats(Context<E> &ctx) {

FILE: src/relocatable.cc
  type mold (line 38) | namespace mold {
    function r_create_synthetic_sections (line 42) | static void r_create_synthetic_sections(Context<E> &ctx) {
    function create_comdat_group_sections (line 68) | static void create_comdat_group_sections(Context<E> &ctx) {
    function r_claim_unresolved_symbols (line 111) | static void r_claim_unresolved_symbols(Context<E> &ctx) {
    function u64 (line 138) | static u64 r_set_osec_offsets(Context<E> &ctx) {
    function combine_objects (line 149) | void combine_objects(Context<E> &ctx) {

FILE: src/shrink-sections.cc
  type mold (line 65) | namespace mold {
    function i64 (line 70) | i64 get_r_delta(InputSection<E> &isec, u64 offset) {
    function shrink_sections (line 78) | void shrink_sections(Context<E> &ctx) {
    function i64 (line 116) | i64 compute_distance(Context<E> &ctx, Symbol<E> &sym,

FILE: src/signal-unix.cc
  type mold (line 11) | namespace mold {
    function errno_string (line 13) | std::string errno_string() {
    function cleanup (line 20) | void cleanup() {
    function sighandler (line 37) | static void sighandler(int signo, siginfo_t *info, void *ucontext) {
    function install_signal_handler (line 66) | void install_signal_handler() {

FILE: src/signal-win32.cc
  type mold (line 5) | namespace mold {
    function cleanup (line 7) | void cleanup() {
    function errno_string (line 12) | std::string errno_string() {
    function LONG (line 28) | static LONG WINAPI vectored_handler(_EXCEPTION_POINTERS *exception_inf...
    function install_signal_handler (line 51) | void install_signal_handler() {

FILE: src/subprocess-unix.cc
  type mold (line 12) | namespace mold {
    function fork_child (line 20) | void fork_child() {
    function notify_parent (line 57) | void notify_parent() {
    function find_dso (line 68) | static std::string find_dso(Context<E> &ctx, std::filesystem::path sel...
    function process_run_subcommand (line 90) | [[noreturn]]

FILE: src/subprocess-win32.cc
  type mold (line 3) | namespace mold {
    function fork_child (line 6) | void fork_child() {}
    function notify_parent (line 9) | void notify_parent() {}
    function process_run_subcommand (line 12) | [[noreturn]]

FILE: src/thunks.cc
  type mold (line 31) | namespace mold {
    function requires_thunk (line 48) | static bool
    function remove_redundant_thunks (line 246) | void remove_redundant_thunks(Context<E> &ctx) {
    function gather_thunk_addresses (line 312) | void gather_thunk_addresses(Context<E> &ctx) {

FILE: src/tls.cc
  type mold (line 150) | namespace mold {
    function u64 (line 157) | u64 get_tp_addr(const ElfPhdr<E> &phdr) {
    function u64 (line 191) | u64 get_dtp_addr(const ElfPhdr<E> &phdr) {

FILE: third-party/blake3/.github/workflows/upload_github_release_asset.py
  function get_release (line 39) | def get_release():

FILE: third-party/blake3/b3sum/src/main.rs
  constant NAME (line 12) | const NAME: &str = "b3sum";
  constant DERIVE_KEY_ARG (line 14) | const DERIVE_KEY_ARG: &str = "derive_key";
  constant KEYED_ARG (line 15) | const KEYED_ARG: &str = "keyed";
  constant LENGTH_ARG (line 16) | const LENGTH_ARG: &str = "length";
  constant NO_NAMES_ARG (line 17) | const NO_NAMES_ARG: &str = "no_names";
  constant RAW_ARG (line 18) | const RAW_ARG: &str = "raw";
  constant TAG_ARG (line 19) | const TAG_ARG: &str = "tag";
  constant CHECK_ARG (line 20) | const CHECK_ARG: &str = "check";
  type Inner (line 24) | struct Inner {
  type Args (line 100) | struct Args {
    method parse (line 107) | fn parse() -> anyhow::Result<Self> {
    method num_threads (line 135) | fn num_threads(&self) -> Option<usize> {
    method check (line 139) | fn check(&self) -> bool {
    method raw (line 143) | fn raw(&self) -> bool {
    method tag (line 147) | fn tag(&self) -> bool {
    method no_mmap (line 151) | fn no_mmap(&self) -> bool {
    method no_names (line 155) | fn no_names(&self) -> bool {
    method len (line 159) | fn len(&self) -> u64 {
    method seek (line 163) | fn seek(&self) -> u64 {
    method keyed (line 167) | fn keyed(&self) -> bool {
    method quiet (line 171) | fn quiet(&self) -> bool {
  function hash_path (line 176) | fn hash_path(args: &Args, path: &Path) -> anyhow::Result<blake3::OutputR...
  function write_hex_output (line 194) | fn write_hex_output(mut output: blake3::OutputReader, args: &Args) -> an...
  function write_raw_output (line 210) | fn write_raw_output(output: blake3::OutputReader, args: &Args) -> anyhow...
  function read_key_from_stdin (line 219) | fn read_key_from_stdin() -> anyhow::Result<[u8; blake3::KEY_LEN]> {
  type FilepathString (line 238) | struct FilepathString {
  function filepath_to_string (line 244) | fn filepath_to_string(filepath: &Path) -> FilepathString {
  function hex_half_byte (line 270) | fn hex_half_byte(c: char) -> anyhow::Result<u8> {
  function check_for_invalid_characters (line 287) | fn check_for_invalid_characters(utf8_path: &str) -> anyhow::Result<()> {
  function unescape (line 311) | fn unescape(mut path: &str) -> anyhow::Result<String> {
  type ParsedCheckLine (line 330) | struct ParsedCheckLine {
  function split_untagged_check_line (line 337) | fn split_untagged_check_line(line_after_slash: &str) -> Option<(&str, &s...
  function split_tagged_check_line (line 343) | fn split_tagged_check_line(line_after_slash: &str) -> Option<(&str, &str...
  function parse_check_line (line 353) | fn parse_check_line(mut line: &str) -> anyhow::Result<ParsedCheckLine> {
  function hash_one_input (line 413) | fn hash_one_input(path: &Path, args: &Args) -> anyhow::Result<()> {
  function check_one_line (line 445) | fn check_one_line(line: &str, args: &Args) -> bool {
  function check_one_checkfile (line 488) | fn check_one_checkfile(path: &Path, args: &Args, files_failed: &mut u64)...
  function main (line 519) | fn main() -> anyhow::Result<()> {
  function test_args (line 561) | fn test_args() {

FILE: third-party/blake3/b3sum/src/unit_tests.rs
  function test_parse_check_line (line 4) | fn test_parse_check_line() {
  function test_filepath_to_string (line 222) | fn test_filepath_to_string() {

FILE: third-party/blake3/b3sum/tests/cli_tests.rs
  function b3sum_exe (line 7) | pub fn b3sum_exe() -> PathBuf {
  function test_hash_one (line 12) | fn test_hash_one() {
  function test_hash_one_tag (line 19) | fn test_hash_one_tag() {
  function test_hash_one_raw (line 29) | fn test_hash_one_raw() {
  function test_hash_many (line 41) | fn test_hash_many() {
  function test_hash_many_tag (line 69) | fn test_hash_many_tag() {
  function test_missing_files (line 91) | fn test_missing_files() {
  function test_hash_length_and_seek (line 122) | fn test_hash_length_and_seek() {
  function test_keyed (line 162) | fn test_keyed() {
  function test_derive_key (line 193) | fn test_derive_key() {
  function test_no_mmap (line 206) | fn test_no_mmap() {
  function test_length_without_value_is_an_error (line 219) | fn test_length_without_value_is_an_error() {
  function test_raw_with_multi_files_is_an_error (line 228) | fn test_raw_with_multi_files_is_an_error() {
  function test_newline_and_backslash_escaping_on_unix (line 245) | fn test_newline_and_backslash_escaping_on_unix() {
  function test_slash_normalization_on_windows (line 288) | fn test_slash_normalization_on_windows() {
  function test_invalid_unicode_on_unix (line 324) | fn test_invalid_unicode_on_unix() {
  function test_invalid_unicode_on_windows (line 366) | fn test_invalid_unicode_on_windows() {
  function test_check (line 409) | fn test_check() {
  function test_check_invalid_characters (line 573) | fn test_check_invalid_characters() {
  function test_globbing (line 647) | fn test_globbing() {

FILE: third-party/blake3/benches/bench.rs
  constant KIB (line 13) | const KIB: usize = 1024;
  type RandomInput (line 18) | pub struct RandomInput {
    method new (line 26) | pub fn new(b: &mut Bencher, len: usize) -> Self {
    method get (line 42) | pub fn get(&mut self) -> &[u8] {
  function bench_single_compression_fn (line 52) | fn bench_single_compression_fn(b: &mut Bencher, platform: Platform) {
  function bench_single_compression_portable (line 60) | fn bench_single_compression_portable(b: &mut Bencher) {
  function bench_single_compression_sse2 (line 66) | fn bench_single_compression_sse2(b: &mut Bencher) {
  function bench_single_compression_sse41 (line 74) | fn bench_single_compression_sse41(b: &mut Bencher) {
  function bench_single_compression_avx512 (line 82) | fn bench_single_compression_avx512(b: &mut Bencher) {
  function bench_many_chunks_fn (line 88) | fn bench_many_chunks_fn(b: &mut Bencher, platform: Platform) {
  function bench_many_chunks_sse2 (line 116) | fn bench_many_chunks_sse2(b: &mut Bencher) {
  function bench_many_chunks_sse41 (line 124) | fn bench_many_chunks_sse41(b: &mut Bencher) {
  function bench_many_chunks_avx2 (line 132) | fn bench_many_chunks_avx2(b: &mut Bencher) {
  function bench_many_chunks_avx512 (line 140) | fn bench_many_chunks_avx512(b: &mut Bencher) {
  function bench_many_chunks_neon (line 148) | fn bench_many_chunks_neon(b: &mut Bencher) {
  function bench_many_chunks_wasm (line 154) | fn bench_many_chunks_wasm(b: &mut Bencher) {
  function bench_many_parents_fn (line 159) | fn bench_many_parents_fn(b: &mut Bencher, platform: Platform) {
  function bench_many_parents_sse2 (line 187) | fn bench_many_parents_sse2(b: &mut Bencher) {
  function bench_many_parents_sse41 (line 195) | fn bench_many_parents_sse41(b: &mut Bencher) {
  function bench_many_parents_avx2 (line 203) | fn bench_many_parents_avx2(b: &mut Bencher) {
  function bench_many_parents_avx512 (line 211) | fn bench_many_parents_avx512(b: &mut Bencher) {
  function bench_many_parents_neon (line 219) | fn bench_many_parents_neon(b: &mut Bencher) {
  function bench_many_parents_wasm (line 225) | fn bench_many_parents_wasm(b: &mut Bencher) {
  function bench_atonce (line 229) | fn bench_atonce(b: &mut Bencher, len: usize) {
  function bench_atonce_0001_block (line 235) | fn bench_atonce_0001_block(b: &mut Bencher) {
  function bench_atonce_0001_kib (line 240) | fn bench_atonce_0001_kib(b: &mut Bencher) {
  function bench_atonce_0002_kib (line 245) | fn bench_atonce_0002_kib(b: &mut Bencher) {
  function bench_atonce_0004_kib (line 250) | fn bench_atonce_0004_kib(b: &mut Bencher) {
  function bench_atonce_0008_kib (line 255) | fn bench_atonce_0008_kib(b: &mut Bencher) {
  function bench_atonce_0016_kib (line 260) | fn bench_atonce_0016_kib(b: &mut Bencher) {
  function bench_atonce_0032_kib (line 265) | fn bench_atonce_0032_kib(b: &mut Bencher) {
  function bench_atonce_0064_kib (line 270) | fn bench_atonce_0064_kib(b: &mut Bencher) {
  function bench_atonce_0128_kib (line 275) | fn bench_atonce_0128_kib(b: &mut Bencher) {
  function bench_atonce_0256_kib (line 280) | fn bench_atonce_0256_kib(b: &mut Bencher) {
  function bench_atonce_0512_kib (line 285) | fn bench_atonce_0512_kib(b: &mut Bencher) {
  function bench_atonce_1024_kib (line 290) | fn bench_atonce_1024_kib(b: &mut Bencher) {
  function bench_incremental (line 294) | fn bench_incremental(b: &mut Bencher, len: usize) {
  function bench_incremental_0001_block (line 300) | fn bench_incremental_0001_block(b: &mut Bencher) {
  function bench_incremental_0001_kib (line 305) | fn bench_incremental_0001_kib(b: &mut Bencher) {
  function bench_incremental_0002_kib (line 310) | fn bench_incremental_0002_kib(b: &mut Bencher) {
  function bench_incremental_0004_kib (line 315) | fn bench_incremental_0004_kib(b: &mut Bencher) {
  function bench_incremental_0008_kib (line 320) | fn bench_incremental_0008_kib(b: &mut Bencher) {
  function bench_incremental_0016_kib (line 325) | fn bench_incremental_0016_kib(b: &mut Bencher) {
  function bench_incremental_0032_kib (line 330) | fn bench_incremental_0032_kib(b: &mut Bencher) {
  function bench_incremental_0064_kib (line 335) | fn bench_incremental_0064_kib(b: &mut Bencher) {
  function bench_incremental_0128_kib (line 340) | fn bench_incremental_0128_kib(b: &mut Bencher) {
  function bench_incremental_0256_kib (line 345) | fn bench_incremental_0256_kib(b: &mut Bencher) {
  function bench_incremental_0512_kib (line 350) | fn bench_incremental_0512_kib(b: &mut Bencher) {
  function bench_incremental_1024_kib (line 355) | fn bench_incremental_1024_kib(b: &mut Bencher) {
  function bench_reference (line 359) | fn bench_reference(b: &mut Bencher, len: usize) {
  function bench_reference_0001_block (line 371) | fn bench_reference_0001_block(b: &mut Bencher) {
  function bench_reference_0001_kib (line 376) | fn bench_reference_0001_kib(b: &mut Bencher) {
  function bench_reference_0002_kib (line 381) | fn bench_reference_0002_kib(b: &mut Bencher) {
  function bench_reference_0004_kib (line 386) | fn bench_reference_0004_kib(b: &mut Bencher) {
  function bench_reference_0008_kib (line 391) | fn bench_reference_0008_kib(b: &mut Bencher) {
  function bench_reference_0016_kib (line 396) | fn bench_reference_0016_kib(b: &mut Bencher) {
  function bench_reference_0032_kib (line 401) | fn bench_reference_0032_kib(b: &mut Bencher) {
  function bench_reference_0064_kib (line 406) | fn bench_reference_0064_kib(b: &mut Bencher) {
  function bench_reference_0128_kib (line 411) | fn bench_reference_0128_kib(b: &mut Bencher) {
  function bench_reference_0256_kib (line 416) | fn bench_reference_0256_kib(b: &mut Bencher) {
  function bench_reference_0512_kib (line 421) | fn bench_reference_0512_kib(b: &mut Bencher) {
  function bench_reference_1024_kib (line 426) | fn bench_reference_1024_kib(b: &mut Bencher) {
  function bench_rayon (line 431) | fn bench_rayon(b: &mut Bencher, len: usize) {
  function bench_rayon_0001_block (line 438) | fn bench_rayon_0001_block(b: &mut Bencher) {
  function bench_rayon_0001_kib (line 444) | fn bench_rayon_0001_kib(b: &mut Bencher) {
  function bench_rayon_0002_kib (line 450) | fn bench_rayon_0002_kib(b: &mut Bencher) {
  function bench_rayon_0004_kib (line 456) | fn bench_rayon_0004_kib(b: &mut Bencher) {
  function bench_rayon_0008_kib (line 462) | fn bench_rayon_0008_kib(b: &mut Bencher) {
  function bench_rayon_0016_kib (line 468) | fn bench_rayon_0016_kib(b: &mut Bencher) {
  function bench_rayon_0032_kib (line 474) | fn bench_rayon_0032_kib(b: &mut Bencher) {
  function bench_rayon_0064_kib (line 480) | fn bench_rayon_0064_kib(b: &mut Bencher) {
  function bench_rayon_0128_kib (line 486) | fn bench_rayon_0128_kib(b: &mut Bencher) {
  function bench_rayon_0256_kib (line 492) | fn bench_rayon_0256_kib(b: &mut Bencher) {
  function bench_rayon_0512_kib (line 498) | fn bench_rayon_0512_kib(b: &mut Bencher) {
  function bench_rayon_1024_kib (line 504) | fn bench_rayon_1024_kib(b: &mut Bencher) {
  function bench_two_updates (line 515) | fn bench_two_updates(b: &mut Bencher) {
  function bench_xof (line 527) | fn bench_xof(b: &mut Bencher, len: usize) {
  function bench_xof_01_block (line 536) | fn bench_xof_01_block(b: &mut Bencher) {
  function bench_xof_02_blocks (line 541) | fn bench_xof_02_blocks(b: &mut Bencher) {
  function bench_xof_03_blocks (line 546) | fn bench_xof_03_blocks(b: &mut Bencher) {
  function bench_xof_04_blocks (line 551) | fn bench_xof_04_blocks(b: &mut Bencher) {
  function bench_xof_05_blocks (line 556) | fn bench_xof_05_blocks(b: &mut Bencher) {
  function bench_xof_06_blocks (line 561) | fn bench_xof_06_blocks(b: &mut Bencher) {
  function bench_xof_07_blocks (line 566) | fn bench_xof_07_blocks(b: &mut Bencher) {
  function bench_xof_08_blocks (line 571) | fn bench_xof_08_blocks(b: &mut Bencher) {
  function bench_xof_09_blocks (line 576) | fn bench_xof_09_blocks(b: &mut Bencher) {
  function bench_xof_10_blocks (line 581) | fn bench_xof_10_blocks(b: &mut Bencher) {
  function bench_xof_11_blocks (line 586) | fn bench_xof_11_blocks(b: &mut Bencher) {
  function bench_xof_12_blocks (line 591) | fn bench_xof_12_blocks(b: &mut Bencher) {
  function bench_xof_13_blocks (line 596) | fn bench_xof_13_blocks(b: &mut Bencher) {
  function bench_xof_14_blocks (line 601) | fn bench_xof_14_blocks(b: &mut Bencher) {
  function bench_xof_15_blocks (line 606) | fn bench_xof_15_blocks(b: &mut Bencher) {
  function bench_xof_16_blocks (line 611) | fn bench_xof_16_blocks(b: &mut Bencher) {
  function bench_xof_32_blocks (line 616) | fn bench_xof_32_blocks(b: &mut Bencher) {
  function bench_xof_64_blocks (line 621) | fn bench_xof_64_blocks(b: &mut Bencher) {

FILE: third-party/blake3/build.rs
  function defined (line 3) | fn defined(var: &str) -> bool {
  function is_pure (line 8) | fn is_pure() -> bool {
  function should_prefer_intrinsics (line 12) | fn should_prefer_intrinsics() -> bool {
  function is_neon (line 16) | fn is_neon() -> bool {
  function is_no_neon (line 20) | fn is_no_neon() -> bool {
  function is_wasm32_simd (line 24) | fn is_wasm32_simd() -> bool {
  function is_ci (line 28) | fn is_ci() -> bool {
  function warn (line 32) | fn warn(warning: &str) {
  function target_components (line 41) | fn target_components() -> Vec<String> {
  function is_x86_64 (line 46) | fn is_x86_64() -> bool {
  function is_windows_target (line 50) | fn is_windows_target() -> bool {
  function use_msvc_asm (line 54) | fn use_msvc_asm() -> bool {
  function is_x86_32 (line 81) | fn is_x86_32() -> bool {
  function is_arm (line 86) | fn is_arm() -> bool {
  function is_aarch64 (line 90) | fn is_aarch64() -> bool {
  function is_armv7 (line 94) | fn is_armv7() -> bool {
  function is_wasm32 (line 98) | fn is_wasm32() -> bool {
  function endianness (line 102) | fn endianness() -> String {
  function is_little_endian (line 108) | fn is_little_endian() -> bool {
  function is_big_endian (line 112) | fn is_big_endian() -> bool {
  function is_windows_msvc (line 120) | fn is_windows_msvc() -> bool {
  function is_windows_gnu (line 132) | fn is_windows_gnu() -> bool {
  function new_build (line 140) | fn new_build() -> cc::Build {
  type CCompilerSupport (line 154) | enum CCompilerSupport {
  function c_compiler_support (line 161) | fn c_compiler_support() -> CCompilerSupport {
  function build_sse2_sse41_avx2_rust_intrinsics (line 197) | fn build_sse2_sse41_avx2_rust_intrinsics() {
  function build_sse2_sse41_avx2_assembly (line 206) | fn build_sse2_sse41_avx2_assembly() {
  function build_avx512_c_intrinsics (line 235) | fn build_avx512_c_intrinsics() {
  function build_avx512_assembly (line 254) | fn build_avx512_assembly() {
  function build_neon_c_intrinsics (line 281) | fn build_neon_c_intrinsics() {
  function build_wasm32_simd (line 296) | fn build_wasm32_simd() {
  function main (line 303) | fn main() -> Result<(), Box<dyn std::error::Error>> {

FILE: third-party/blake3/reference_impl/reference_impl.rs
  constant OUT_LEN (line 22) | const OUT_LEN: usize = 32;
  constant KEY_LEN (line 23) | const KEY_LEN: usize = 32;
  constant BLOCK_LEN (line 24) | const BLOCK_LEN: usize = 64;
  constant CHUNK_LEN (line 25) | const CHUNK_LEN: usize = 1024;
  constant CHUNK_START (line 27) | const CHUNK_START: u32 = 1 << 0;
  constant CHUNK_END (line 28) | const CHUNK_END: u32 = 1 << 1;
  constant PARENT (line 29) | const PARENT: u32 = 1 << 2;
  constant ROOT (line 30) | const ROOT: u32 = 1 << 3;
  constant KEYED_HASH (line 31) | const KEYED_HASH: u32 = 1 << 4;
  constant DERIVE_KEY_CONTEXT (line 32) | const DERIVE_KEY_CONTEXT: u32 = 1 << 5;
  constant DERIVE_KEY_MATERIAL (line 33) | const DERIVE_KEY_MATERIAL: u32 = 1 << 6;
  constant IV (line 35) | const IV: [u32; 8] = [
  constant MSG_PERMUTATION (line 39) | const MSG_PERMUTATION: [usize; 16] = [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 1...
  function g (line 42) | fn g(state: &mut [u32; 16], a: usize, b: usize, c: usize, d: usize, mx: ...
  function round (line 53) | fn round(state: &mut [u32; 16], m: &[u32; 16]) {
  function permute (line 66) | fn permute(m: &mut [u32; 16]) {
  function compress (line 74) | fn compress(
  function first_8_words (line 113) | fn first_8_words(compression_output: [u32; 16]) -> [u32; 8] {
  function words_from_little_endian_bytes (line 117) | fn words_from_little_endian_bytes(bytes: &[u8], words: &mut [u32]) {
  type Output (line 127) | struct Output {
    method chaining_value (line 136) | fn chaining_value(&self) -> [u32; 8] {
    method root_output_bytes (line 146) | fn root_output_bytes(&self, out_slice: &mut [u8]) {
  type ChunkState (line 165) | struct ChunkState {
    method new (line 175) | fn new(key_words: [u32; 8], chunk_counter: u64, flags: u32) -> Self {
    method len (line 186) | fn len(&self) -> usize {
    method start_flag (line 190) | fn start_flag(&self) -> u32 {
    method update (line 198) | fn update(&mut self, mut input: &[u8]) {
    method output (line 226) | fn output(&self) -> Output {
  function parent_output (line 239) | fn parent_output(
  function parent_cv (line 257) | fn parent_cv(
  type Hasher (line 267) | pub struct Hasher {
    method new_internal (line 276) | fn new_internal(key_words: [u32; 8], flags: u32) -> Self {
    method new (line 287) | pub fn new() -> Self {
    method new_keyed (line 292) | pub fn new_keyed(key: &[u8; KEY_LEN]) -> Self {
    method new_derive_key (line 300) | pub fn new_derive_key(context: &str) -> Self {
    method push_stack (line 310) | fn push_stack(&mut self, cv: [u32; 8]) {
    method pop_stack (line 315) | fn pop_stack(&mut self) -> [u32; 8] {
    method add_chunk_chaining_value (line 321) | fn add_chunk_chaining_value(&mut self, mut new_cv: [u32; 8], mut total...
    method update (line 337) | pub fn update(&mut self, mut input: &[u8]) {
    method finalize (line 357) | pub fn finalize(&self, out_slice: &mut [u8]) {

FILE: third-party/blake3/src/ffi_avx2.rs
  function hash_many (line 7) | pub unsafe fn hash_many<const N: usize>(
  function blake3_hash_many_avx2 (line 39) | pub fn blake3_hash_many_avx2(
  function test_hash_many (line 59) | fn test_hash_many() {

FILE: third-party/blake3/src/ffi_avx512.rs
  function compress_in_place (line 4) | pub unsafe fn compress_in_place(
  function compress_xof (line 23) | pub unsafe fn compress_xof(
  function hash_many (line 45) | pub unsafe fn hash_many<const N: usize>(
  function xof_many (line 77) | pub unsafe fn xof_many(
  function blake3_compress_in_place_avx512 (line 101) | pub fn blake3_compress_in_place_avx512(
  function blake3_compress_xof_avx512 (line 108) | pub fn blake3_compress_xof_avx512(
  function blake3_hash_many_avx512 (line 116) | pub fn blake3_hash_many_avx512(
  function blake3_xof_many_avx512 (line 129) | pub fn blake3_xof_many_avx512(
  function test_compress (line 146) | fn test_compress() {
  function test_hash_many (line 154) | fn test_hash_many() {
  function test_xof_many (line 163) | fn test_xof_many() {

FILE: third-party/blake3/src/ffi_neon.rs
  function hash_many (line 4) | pub unsafe fn hash_many<const N: usize>(
  function blake3_compress_in_place_portable (line 37) | pub extern "C" fn blake3_compress_in_place_portable(
  function blake3_hash_many_neon (line 57) | pub fn blake3_hash_many_neon(
  function test_hash_many (line 77) | fn test_hash_many() {

FILE: third-party/blake3/src/ffi_sse2.rs
  function compress_in_place (line 4) | pub unsafe fn compress_in_place(
  function compress_xof (line 23) | pub unsafe fn compress_xof(
  function hash_many (line 45) | pub unsafe fn hash_many<const N: usize>(
  function blake3_compress_in_place_sse2 (line 77) | pub fn blake3_compress_in_place_sse2(
  function blake3_compress_xof_sse2 (line 84) | pub fn blake3_compress_xof_sse2(
  function blake3_hash_many_sse2 (line 92) | pub fn blake3_hash_many_sse2(
  function test_compress (line 112) | fn test_compress() {
  function test_hash_many (line 120) | fn test_hash_many() {

FILE: third-party/blake3/src/ffi_sse41.rs
  function compress_in_place (line 4) | pub unsafe fn compress_in_place(
  function compress_xof (line 23) | pub unsafe fn compress_xof(
  function hash_many (line 45) | pub unsafe fn hash_many<const N: usize>(
  function blake3_compress_in_place_sse41 (line 77) | pub fn blake3_compress_in_place_sse41(
  function blake3_compress_xof_sse41 (line 84) | pub fn blake3_compress_xof_sse41(
  function blake3_hash_many_sse41 (line 92) | pub fn blake3_hash_many_sse41(
  function test_compress (line 112) | fn test_compress() {
  function test_hash_many (line 120) | fn test_hash_many() {

FILE: third-party/blake3/src/guts.rs
  type ChunkState (line 6) | pub struct ChunkState(crate::ChunkState);
    method new (line 11) | pub fn new(chunk_counter: u64) -> Self {
    method len (line 21) | pub fn len(&self) -> usize {
    method update (line 26) | pub fn update(&mut self, input: &[u8]) -> &mut Self {
    method finalize (line 31) | pub fn finalize(&self, is_root: bool) -> crate::Hash {
  function parent_cv (line 43) | pub fn parent_cv(

FILE: third-party/blake3/src/hazmat.rs
  type HasherExt (line 156) | pub trait HasherExt {
    method new_from_context_key (line 175) | fn new_from_context_key(context_key: &ContextKey) -> Self;
    method set_input_offset (line 203) | fn set_input_offset(&mut self, offset: u64) -> &mut Self;
    method finalize_non_root (line 214) | fn finalize_non_root(&self) -> ChainingValue;
    method new_from_context_key (line 218) | fn new_from_context_key(context_key: &[u8; KEY_LEN]) -> Hasher {
    method set_input_offset (line 223) | fn set_input_offset(&mut self, offset: u64) -> &mut Hasher {
    method finalize_non_root (line 236) | fn finalize_non_root(&self) -> ChainingValue {
  function max_subtree_len (line 291) | pub fn max_subtree_len(input_offset: u64) -> Option<u64> {
  function test_max_subtree_len (line 302) | fn test_max_subtree_len() {
  function left_subtree_len (line 371) | pub fn left_subtree_len(input_len: u64) -> u64 {
  function test_left_subtree_len (line 378) | fn test_left_subtree_len() {
  type Mode (line 392) | pub enum Mode<'a> {
  function key_words (line 406) | fn key_words(&self) -> CVWords {
  function flags_byte (line 414) | fn flags_byte(&self) -> u8 {
  type ChainingValue (line 428) | pub type ChainingValue = [u8; OUT_LEN];
  function merge_subtrees_inner (line 430) | fn merge_subtrees_inner(
  function merge_subtrees_non_root (line 451) | pub fn merge_subtrees_non_root(
  function merge_subtrees_root (line 469) | pub fn merge_subtrees_root(
  function merge_subtrees_root_xof (line 519) | pub fn merge_subtrees_root_xof(
  type ContextKey (line 528) | pub type ContextKey = [u8; KEY_LEN];
  function hash_derive_key_context (line 548) | pub fn hash_derive_key_context(context: &str) -> ContextKey {
  function test_empty_subtree_should_panic (line 564) | fn test_empty_subtree_should_panic() {
  function test_unaligned_offset_should_panic (line 570) | fn test_unaligned_offset_should_panic() {
  function test_hasher_already_accepted_input_should_panic (line 576) | fn test_hasher_already_accepted_input_should_panic() {
  function test_too_much_input_should_panic (line 582) | fn test_too_much_input_should_panic() {
  function test_set_input_offset_cant_finalize (line 590) | fn test_set_input_offset_cant_finalize() {
  function test_set_input_offset_cant_finalize_xof (line 596) | fn test_set_input_offset_cant_finalize_xof() {
  function test_grouped_hash (line 603) | fn test_grouped_hash() {
  function test_keyed_hash_xof (line 662) | fn test_keyed_hash_xof() {
  function test_derive_key (line 687) | fn test_derive_key() {

FILE: third-party/blake3/src/io.rs
  function copy_wide (line 4) | pub(crate) fn copy_wide(
  function maybe_mmap_file (line 50) | pub(crate) fn maybe_mmap_file(file: &std::fs::File) -> std::io::Result<O...

FILE: third-party/blake3/src/join.rs
  type Join (line 22) | pub trait Join {
    method join (line 23) | fn join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
    method join (line 41) | fn join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
    method join (line 63) | fn join<A, B, RA, RB>(oper_a: A, oper_b: B) -> (RA, RB)
  type SerialJoin (line 37) | pub enum SerialJoin {}
  type RayonJoin (line 58) | pub enum RayonJoin {}
  function test_serial_join (line 79) | fn test_serial_join() {
  function test_rayon_join (line 87) | fn test_rayon_join() {

FILE: third-party/blake3/src/lib.rs
  constant OUT_LEN (line 152) | pub const OUT_LEN: usize = 32;
  constant KEY_LEN (line 155) | pub const KEY_LEN: usize = 32;
  constant BLOCK_LEN (line 162) | pub const BLOCK_LEN: usize = 64;
  constant CHUNK_LEN (line 168) | pub const CHUNK_LEN: usize = 1024;
  constant MAX_DEPTH (line 170) | const MAX_DEPTH: usize = 54;
  type CVWords (line 177) | type CVWords = [u32; 8];
  type CVBytes (line 178) | type CVBytes = [u8; 32];
  constant IV (line 180) | const IV: &CVWords = &[
  constant MSG_SCHEDULE (line 184) | const MSG_SCHEDULE: [[usize; 16]; 7] = [
  constant CHUNK_START (line 198) | const CHUNK_START: u8 = 1 << 0;
  constant CHUNK_END (line 199) | const CHUNK_END: u8 = 1 << 1;
  constant PARENT (line 200) | const PARENT: u8 = 1 << 2;
  constant ROOT (line 201) | const ROOT: u8 = 1 << 3;
  constant KEYED_HASH (line 202) | const KEYED_HASH: u8 = 1 << 4;
  constant DERIVE_KEY_CONTEXT (line 203) | const DERIVE_KEY_CONTEXT: u8 = 1 << 5;
  constant DERIVE_KEY_MATERIAL (line 204) | const DERIVE_KEY_MATERIAL: u8 = 1 << 6;
  function counter_low (line 207) | fn counter_low(counter: u64) -> u32 {
  function counter_high (line 212) | fn counter_high(counter: u64) -> u32 {
  type Hash (line 242) | pub struct Hash([u8; OUT_LEN]);
    method as_bytes (line 249) | pub const fn as_bytes(&self) -> &[u8; OUT_LEN] {
    method from_bytes (line 254) | pub const fn from_bytes(bytes: [u8; OUT_LEN]) -> Self {
    method from_slice (line 261) | pub fn from_slice(bytes: &[u8]) -> Result<Self, core::array::TryFromSl...
    method to_hex (line 273) | pub fn to_hex(&self) -> ArrayString<{ 2 * OUT_LEN }> {
    method from_hex (line 292) | pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Self, HexError> {
    method from (line 315) | fn from(bytes: [u8; OUT_LEN]) -> Self {
    type Err (line 328) | type Err = HexError;
    method from_str (line 330) | fn from_str(s: &str) -> Result<Self, Self::Err> {
    method eq (line 355) | fn eq(&self, other: &[u8; OUT_LEN]) -> bool {
    method eq (line 363) | fn eq(&self, other: &[u8]) -> bool {
    method fmt (line 369) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 381) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function from (line 322) | fn from(hash: Hash) -> Self {
  method zeroize (line 337) | fn zeroize(&mut self) {
  method eq (line 347) | fn eq(&self, other: &Hash) -> bool {
  type HexError (line 398) | pub struct HexError(HexErrorInner);
    method fmt (line 407) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type HexErrorInner (line 401) | enum HexErrorInner {
  type Output (line 430) | struct Output {
    method chaining_value (line 440) | fn chaining_value(&self) -> CVBytes {
    method root_hash (line 452) | fn root_hash(&self) -> Hash {
    method root_output_block (line 460) | fn root_output_block(&self) -> [u8; 2 * OUT_LEN] {
  method zeroize (line 473) | fn zeroize(&mut self) {
  type ChunkState (line 493) | struct ChunkState {
    method new (line 504) | fn new(key: &CVWords, chunk_counter: u64, flags: u8, platform: Platfor...
    method count (line 516) | fn count(&self) -> usize {
    method fill_buf (line 520) | fn fill_buf(&mut self, input: &mut &[u8]) {
    method start_flag (line 528) | fn start_flag(&self) -> u8 {
    method update (line 538) | fn update(&mut self, mut input: &[u8]) -> &mut Self {
    method output (line 577) | fn output(&self) -> Output {
    method fmt (line 592) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method zeroize (line 604) | fn zeroize(&mut self) {
  type IncrementCounter (line 643) | pub enum IncrementCounter {
    method yes (line 650) | fn yes(&self) -> bool {
  function largest_power_of_two_leq (line 660) | fn largest_power_of_two_leq(n: usize) -> usize {
  function compress_chunks_parallel (line 668) | fn compress_chunks_parallel(
  function compress_parents_parallel (line 715) | fn compress_parents_parallel(
  function compress_subtree_wide (line 772) | fn compress_subtree_wide<J: join::Join>(
  function compress_subtree_to_parent_node (line 846) | fn compress_subtree_to_parent_node<J: join::Join>(
  function hash_all_at_once (line 873) | fn hash_all_at_once<J: join::Join>(input: &[u8], key: &CVWords, flags: u...
  function hash (line 914) | pub fn hash(input: &[u8]) -> Hash {
  function keyed_hash (line 943) | pub fn keyed_hash(key: &[u8; KEY_LEN], input: &[u8]) -> Hash {
  function derive_key (line 997) | pub fn derive_key(context: &str, key_material: &[u8]) -> [u8; OUT_LEN] {
  function parent_node_output (line 1005) | fn parent_node_output(
  type Hasher (line 1060) | pub struct Hasher {
    method new_internal (line 1073) | fn new_internal(key: &CVWords, flags: u8) -> Self {
    method new (line 1083) | pub fn new() -> Self {
    method new_keyed (line 1091) | pub fn new_keyed(key: &[u8; KEY_LEN]) -> Self {
    method new_derive_key (line 1101) | pub fn new_derive_key(context: &str) -> Self {
    method reset (line 1111) | pub fn reset(&mut self) -> &mut Self {
    method merge_cv_stack (line 1133) | fn merge_cv_stack(&mut self, chunk_counter: u64) {
    method push_cv (line 1186) | fn push_cv(&mut self, new_cv: &CVBytes, chunk_counter: u64) {
    method update (line 1198) | pub fn update(&mut self, input: &[u8]) -> &mut Self {
    method update_with_join (line 1202) | fn update_with_join<J: join::Join>(&mut self, mut input: &[u8]) -> &mu...
    method final_output (line 1333) | fn final_output(&self) -> Output {
    method finalize (line 1392) | pub fn finalize(&self) -> Hash {
    method finalize_xof (line 1407) | pub fn finalize_xof(&self) -> OutputReader {
    method count (line 1419) | pub fn count(&self) -> u64 {
    method update_reader (line 1465) | pub fn update_reader(&mut self, reader: impl std::io::Read) -> std::io...
    method update_rayon (line 1491) | pub fn update_rayon(&mut self, input: &[u8]) -> &mut Self {
    method update_mmap (line 1537) | pub fn update_mmap(&mut self, path: impl AsRef<std::path::Path>) -> st...
    method update_mmap_rayon (line 1589) | pub fn update_mmap_rayon(
    method fmt (line 1605) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method write (line 1624) | fn write(&mut self, input: &[u8]) -> std::io::Result<usize> {
    method flush (line 1630) | fn flush(&mut self) -> std::io::Result<()> {
  method default (line 1615) | fn default() -> Self {
  method zeroize (line 1637) | fn zeroize(&mut self) {
  type OutputReader (line 1677) | pub struct OutputReader {
    method new (line 1683) | fn new(inner: Output) -> Self {
    method fill_one_block (line 1693) | fn fill_one_block(&mut self, buf: &mut &mut [u8]) {
    method fill (line 1722) | pub fn fill(&mut self, mut buf: &mut [u8]) {
    method position (line 1764) | pub fn position(&self) -> u64 {
    method set_position (line 1774) | pub fn set_position(&mut self, position: u64) {
    method fmt (line 1782) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method read (line 1792) | fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
    method seek (line 1800) | fn seek(&mut self, pos: std::io::SeekFrom) -> std::io::Result<u64> {
  method zeroize (line 1825) | fn zeroize(&mut self) {

FILE: third-party/blake3/src/platform.rs
  type Platform (line 45) | pub enum Platform {
    method detect (line 65) | pub fn detect() -> Self {
    method simd_degree (line 102) | pub fn simd_degree(&self) -> usize {
    method compress_in_place (line 123) | pub fn compress_in_place(
    method compress_xof (line 159) | pub fn compress_xof(
    method hash_many (line 205) | pub fn hash_many<const N: usize>(
    method xof_many (line 315) | pub fn xof_many(
    method portable (line 352) | pub fn portable() -> Self {
    method sse2 (line 357) | pub fn sse2() -> Option<Self> {
    method sse41 (line 366) | pub fn sse41() -> Option<Self> {
    method avx2 (line 375) | pub fn avx2() -> Option<Self> {
    method avx512 (line 385) | pub fn avx512() -> Option<Self> {
    method neon (line 394) | pub fn neon() -> Option<Self> {
    method wasm32_simd (line 400) | pub fn wasm32_simd() -> Option<Self> {
  function avx512_detected (line 412) | pub fn avx512_detected() -> bool {
  function avx2_detected (line 439) | pub fn avx2_detected() -> bool {
  function sse41_detected (line 466) | pub fn sse41_detected() -> bool {
  function sse2_detected (line 493) | pub fn sse2_detected() -> bool {
  function words_from_le_bytes_32 (line 518) | pub fn words_from_le_bytes_32(bytes: &[u8; 32]) -> [u32; 8] {
  function words_from_le_bytes_64 (line 532) | pub fn words_from_le_bytes_64(bytes: &[u8; 64]) -> [u32; 16] {
  function le_bytes_from_words_32 (line 554) | pub fn le_bytes_from_words_32(words: &[u32; 8]) -> [u8; 32] {
  function le_bytes_from_words_64 (line 568) | pub fn le_bytes_from_words_64(words: &[u32; 16]) -> [u8; 64] {

FILE: third-party/blake3/src/portable.rs
  function g (line 8) | fn g(state: &mut [u32; 16], a: usize, b: usize, c: usize, d: usize, x: u...
  function round (line 20) | fn round(state: &mut [u32; 16], msg: &[u32; 16], round: usize) {
  function compress_pre (line 38) | fn compress_pre(
  function compress_in_place (line 77) | pub fn compress_in_place(
  function compress_xof (line 96) | pub fn compress_xof(
  function hash1 (line 123) | pub fn hash1<const N: usize>(
  function hash_many (line 153) | pub fn hash_many<const N: usize>(
  function test_compress (line 189) | fn test_compress() {
  function test_hash_many (line 195) | fn test_hash_many() {

FILE: third-party/blake3/src/rust_avx2.rs
  constant DEGREE (line 11) | pub const DEGREE: usize = 8;
  function loadu (line 14) | unsafe fn loadu(src: *const u8) -> __m256i {
  function storeu (line 20) | unsafe fn storeu(src: __m256i, dest: *mut u8) {
  function add (line 26) | unsafe fn add(a: __m256i, b: __m256i) -> __m256i {
  function xor (line 31) | unsafe fn xor(a: __m256i, b: __m256i) -> __m256i {
  function set1 (line 36) | unsafe fn set1(x: u32) -> __m256i {
  function set8 (line 41) | unsafe fn set8(a: u32, b: u32, c: u32, d: u32, e: u32, f: u32, g: u32, h...
  function rot16 (line 56) | unsafe fn rot16(x: __m256i) -> __m256i {
  function rot12 (line 61) | unsafe fn rot12(x: __m256i) -> __m256i {
  function rot8 (line 66) | unsafe fn rot8(x: __m256i) -> __m256i {
  function rot7 (line 71) | unsafe fn rot7(x: __m256i) -> __m256i {
  function round (line 76) | unsafe fn round(v: &mut [__m256i; 16], m: &[__m256i; 16], r: usize) {
  function interleave128 (line 193) | unsafe fn interleave128(a: __m256i, b: __m256i) -> (__m256i, __m256i) {
  function transpose_vecs (line 207) | unsafe fn transpose_vecs(vecs: &mut [__m256i; DEGREE]) {
  function transpose_msg_vecs (line 245) | unsafe fn transpose_msg_vecs(inputs: &[*const u8; DEGREE], block_offset:...
  function load_counters (line 274) | unsafe fn load_counters(counter: u64, increment_counter: IncrementCounte...
  function hash8 (line 301) | pub unsafe fn hash8(
  function hash_many (line 386) | pub unsafe fn hash_many<const N: usize>(
  function test_transpose (line 436) | fn test_transpose() {
  function test_hash_many (line 468) | fn test_hash_many() {

FILE: third-party/blake3/src/rust_sse2.rs
  constant DEGREE (line 12) | pub const DEGREE: usize = 4;
  function loadu (line 15) | unsafe fn loadu(src: *const u8) -> __m128i {
  function storeu (line 21) | unsafe fn storeu(src: __m128i, dest: *mut u8) {
  function add (line 27) | unsafe fn add(a: __m128i, b: __m128i) -> __m128i {
  function xor (line 32) | unsafe fn xor(a: __m128i, b: __m128i) -> __m128i {
  function set1 (line 37) | unsafe fn set1(x: u32) -> __m128i {
  function set4 (line 42) | unsafe fn set4(a: u32, b: u32, c: u32, d: u32) -> __m128i {
  function rot16 (line 55) | unsafe fn rot16(a: __m128i) -> __m128i {
  function rot12 (line 60) | unsafe fn rot12(a: __m128i) -> __m128i {
  function rot8 (line 65) | unsafe fn rot8(a: __m128i) -> __m128i {
  function rot7 (line 70) | unsafe fn rot7(a: __m128i) -> __m128i {
  function g1 (line 75) | unsafe fn g1(
  function g2 (line 91) | unsafe fn g2(
  function diagonalize (line 127) | unsafe fn diagonalize(row0: &mut __m128i, row2: &mut __m128i, row3: &mut...
  function undiagonalize (line 134) | unsafe fn undiagonalize(row0: &mut __m128i, row2: &mut __m128i, row3: &m...
  function blend_epi16 (line 141) | unsafe fn blend_epi16(a: __m128i, b: __m128i, imm8: i32) -> __m128i {
  function compress_pre (line 150) | unsafe fn compress_pre(
  function compress_in_place (line 336) | pub unsafe fn compress_in_place(
  function compress_xof (line 349) | pub unsafe fn compress_xof(
  function round (line 366) | unsafe fn round(v: &mut [__m128i; 16], m: &[__m128i; 16], r: usize) {
  function transpose_vecs (line 483) | unsafe fn transpose_vecs(vecs: &mut [__m128i; DEGREE]) {
  function transpose_msg_vecs (line 505) | unsafe fn transpose_msg_vecs(inputs: &[*const u8; DEGREE], block_offset:...
  function load_counters (line 536) | unsafe fn load_counters(counter: u64, increment_counter: IncrementCounte...
  function hash4 (line 555) | pub unsafe fn hash4(
  function hash1 (line 644) | unsafe fn hash1<const N: usize>(
  function hash_many (line 675) | pub unsafe fn hash_many<const N: usize>(
  function test_transpose (line 729) | fn test_transpose() {
  function test_compress (line 761) | fn test_compress() {
  function test_hash_many (line 769) | fn test_hash_many() {

FILE: third-party/blake3/src/rust_sse41.rs
  constant DEGREE (line 12) | pub const DEGREE: usize = 4;
  function loadu (line 15) | unsafe fn loadu(src: *const u8) -> __m128i {
  function storeu (line 21) | unsafe fn storeu(src: __m128i, dest: *mut u8) {
  function add (line 27) | unsafe fn add(a: __m128i, b: __m128i) -> __m128i {
  function xor (line 32) | unsafe fn xor(a: __m128i, b: __m128i) -> __m128i {
  function set1 (line 37) | unsafe fn set1(x: u32) -> __m128i {
  function set4 (line 42) | unsafe fn set4(a: u32, b: u32, c: u32, d: u32) -> __m128i {
  function rot16 (line 55) | unsafe fn rot16(a: __m128i) -> __m128i {
  function rot12 (line 60) | unsafe fn rot12(a: __m128i) -> __m128i {
  function rot8 (line 65) | unsafe fn rot8(a: __m128i) -> __m128i {
  function rot7 (line 70) | unsafe fn rot7(a: __m128i) -> __m128i {
  function g1 (line 75) | unsafe fn g1(
  function g2 (line 91) | unsafe fn g2(
  function diagonalize (line 127) | unsafe fn diagonalize(row0: &mut __m128i, row2: &mut __m128i, row3: &mut...
  function undiagonalize (line 134) | unsafe fn undiagonalize(row0: &mut __m128i, row2: &mut __m128i, row3: &m...
  function compress_pre (line 141) | unsafe fn compress_pre(
  function compress_in_place (line 327) | pub unsafe fn compress_in_place(
  function compress_xof (line 340) | pub unsafe fn compress_xof(
  function round (line 357) | unsafe fn round(v: &mut [__m128i; 16], m: &[__m128i; 16], r: usize) {
  function transpose_vecs (line 474) | unsafe fn transpose_vecs(vecs: &mut [__m128i; DEGREE]) {
  function transpose_msg_vecs (line 496) | unsafe fn transpose_msg_vecs(inputs: &[*const u8; DEGREE], block_offset:...
  function load_counters (line 527) | unsafe fn load_counters(counter: u64, increment_counter: IncrementCounte...
  function hash4 (line 546) | pub unsafe fn hash4(
  function hash1 (line 635) | unsafe fn hash1<const N: usize>(
  function hash_many (line 666) | pub unsafe fn hash_many<const N: usize>(
  function test_transpose (line 720) | fn test_transpose() {
  function test_compress (line 752) | fn test_compress() {
  function test_hash_many (line 760) | fn test_hash_many() {

FILE: third-party/blake3/src/test.rs
  constant TEST_CASES (line 8) | pub const TEST_CASES: &[usize] = &[
  constant TEST_CASES_MAX (line 50) | pub const TEST_CASES_MAX: usize = 100 * CHUNK_LEN;
  constant TEST_KEY (line 53) | pub const TEST_KEY: CVBytes = *b"whats the Elvish word for friend";
  constant TEST_KEY_WORDS (line 54) | pub const TEST_KEY_WORDS: CVWords = [
  function paint_test_input (line 62) | pub fn paint_test_input(buf: &mut [u8]) {
  type CompressInPlaceFn (line 68) | type CompressInPlaceFn =
  type CompressXofFn (line 71) | type CompressXofFn = unsafe fn(
  function test_compress_fn (line 80) | pub fn test_compress_fn(compress_in_place_fn: CompressInPlaceFn, compres...
  type HashManyFn (line 102) | type HashManyFn<A> = unsafe fn(
  function test_hash_many_fn (line 114) | pub fn test_hash_many_fn(
  type XofManyFunction (line 214) | type XofManyFunction = unsafe fn(
  function test_xof_many_fn (line 225) | pub fn test_xof_many_fn(xof_many_function: XofManyFunction) {
  function test_key_bytes_equal_key_words (line 284) | fn test_key_bytes_equal_key_words() {
  function test_reference_impl_size (line 292) | fn test_reference_impl_size() {
  function test_counter_words (line 302) | fn test_counter_words() {
  function test_largest_power_of_two_leq (line 309) | fn test_largest_power_of_two_leq() {
  function test_compare_reference_impl (line 335) | fn test_compare_reference_impl() {
  function test_compare_reference_impl_long_xof (line 435) | fn test_compare_reference_impl_long_xof() {
  function test_xof_partial_blocks (line 450) | fn test_xof_partial_blocks() {
  function reference_hash (line 471) | fn reference_hash(input: &[u8]) -> crate::Hash {
  function test_compare_update_multiple (line 480) | fn test_compare_update_multiple() {
  function test_fuzz_hasher (line 516) | fn test_fuzz_hasher() {
  function test_fuzz_xof (line 548) | fn test_fuzz_xof() {
  function test_xof_seek (line 584) | fn test_xof_seek() {
  function test_msg_schedule_permutation (line 628) | fn test_msg_schedule_permutation() {
  function test_reset (line 644) | fn test_reset() {
  function test_hex_encoding_decoding (line 671) | fn test_hex_encoding_decoding() {
  function test_issue_206_windows_sse2 (line 719) | fn test_issue_206_windows_sse2() {
  function test_hash_conversions (line 739) | fn test_hash_conversions() {
  function test_hash_const_conversions (line 767) | const fn test_hash_const_conversions() {
  function test_zeroize (line 775) | fn test_zeroize() {
  function test_update_reader (line 838) | fn test_update_reader() -> Result<(), std::io::Error> {
  function test_update_reader_interrupted (line 852) | fn test_update_reader_interrupted() -> std::io::Result<()> {
  function test_mmap (line 891) | fn test_mmap() -> Result<(), std::io::Error> {
  function test_mmap_virtual_file (line 912) | fn test_mmap_virtual_file() -> Result<(), std::io::Error> {
  function test_mmap_rayon (line 933) | fn test_mmap_rayon() -> Result<(), std::io::Error> {
  function test_serde (line 954) | fn test_serde() {
  function test_miri_smoketest (line 1003) | fn test_miri_smoketest() {
  function test_chunk (line 1022) | fn test_chunk() {
  function test_parents (line 1030) | fn test_parents() {

FILE: third-party/blake3/src/traits.rs
  method update (line 14) | fn update(&mut self, data: &[u8]) {
  method reset (line 21) | fn reset(&mut self) {
  type OutputSize (line 27) | type OutputSize = U32;
  method finalize_into (line 32) | fn finalize_into(self, out: &mut GenericArray<u8, Self::OutputSize>) {
  method finalize_into_reset (line 39) | fn finalize_into_reset(&mut self, out: &mut GenericArray<u8, Self::Outpu...
  type Reader (line 46) | type Reader = OutputReader;
  method finalize_xof (line 49) | fn finalize_xof(self) -> Self::Reader {
  method finalize_xof_reset (line 56) | fn finalize_xof_reset(&mut self) -> Self::Reader {
  method read (line 65) | fn read(&mut self, buffer: &mut [u8]) {
  type KeySize (line 71) | type KeySize = U32;
  type BlockSize (line 75) | type BlockSize = U64;
  method new (line 82) | fn new(key: &digest::Key<Self>) -> Self {
  function test_digest_traits (line 93) | fn test_digest_traits() {
  function test_mac_trait (line 153) | fn test_mac_trait() {
  function expected_hmac_blake3 (line 174) | fn expected_hmac_blake3(key: &[u8], input: &[u8]) -> [u8; 32] {
  function test_hmac_compatibility (line 199) | fn test_hmac_compatibility() {

FILE: third-party/blake3/src/wasm32_simd.rs
  constant DEGREE (line 25) | pub const DEGREE: usize = 4;
  function loadu (line 28) | unsafe fn loadu(src: *const u8) -> v128 {
  function storeu (line 34) | unsafe fn storeu(src: v128, dest: *mut u8) {
  function add (line 40) | fn add(a: v128, b: v128) -> v128 {
  function xor (line 45) | fn xor(a: v128, b: v128) -> v128 {
  function set1 (line 50) | fn set1(x: u32) -> v128 {
  function set4 (line 55) | fn set4(a: u32, b: u32, c: u32, d: u32) -> v128 {
  function rot16 (line 67) | fn rot16(a: v128) -> v128 {
  function rot12 (line 72) | fn rot12(a: v128) -> v128 {
  function rot8 (line 77) | fn rot8(a: v128) -> v128 {
  function rot7 (line 82) | fn rot7(a: v128) -> v128 {
  function g1 (line 87) | fn g1(row0: &mut v128, row1: &mut v128, row2: &mut v128, row3: &mut v128...
  function g2 (line 97) | fn g2(row0: &mut v128, row1: &mut v128, row2: &mut v128, row3: &mut v128...
  function unpacklo_epi64 (line 114) | fn unpacklo_epi64(a: v128, b: v128) -> v128 {
  function unpackhi_epi64 (line 119) | fn unpackhi_epi64(a: v128, b: v128) -> v128 {
  function unpacklo_epi32 (line 124) | fn unpacklo_epi32(a: v128, b: v128) -> v128 {
  function unpackhi_epi32 (line 129) | fn unpackhi_epi32(a: v128, b: v128) -> v128 {
  function shuffle_epi32 (line 134) | fn shuffle_epi32<const I3: usize, const I2: usize, const I1: usize, cons...
  function blend_epi16 (line 144) | fn blend_epi16(a: v128, b: v128, imm8: i32) -> v128 {
  function diagonalize (line 159) | fn diagonalize(row0: &mut v128, row2: &mut v128, row3: &mut v128) {
  function undiagonalize (line 166) | fn undiagonalize(row0: &mut v128, row2: &mut v128, row3: &mut v128) {
  function compress_pre (line 173) | fn compress_pre(
  function compress_in_place (line 361) | pub fn compress_in_place(
  function compress_xof (line 378) | pub fn compress_xof(
  function round (line 398) | fn round(v: &mut [v128; 16], m: &[v128; 16], r: usize) {
  function transpose_vecs (line 515) | fn transpose_vecs(vecs: &mut [v128; DEGREE]) {
  function transpose_msg_vecs (line 537) | unsafe fn transpose_msg_vecs(inputs: &[*const u8; DEGREE], block_offset:...
  function load_counters (line 565) | fn load_counters(counter: u64, increment_counter: IncrementCounter) -> (...
  function hash4 (line 584) | pub unsafe fn hash4(
  function hash1 (line 673) | unsafe fn hash1<const N: usize>(
  function hash_many (line 704) | pub unsafe fn hash_many<const N: usize>(
  function test_transpose (line 758) | fn test_transpose() {
  function test_compress (line 786) | fn test_compress() {
  function test_hash_many (line 791) | fn test_hash_many() {

FILE: third-party/blake3/test_vectors/src/bin/generate.rs
  function main (line 1) | fn main() {

FILE: third-party/blake3/test_vectors/src/lib.rs
  constant TEST_VECTORS_JSON (line 6) | const TEST_VECTORS_JSON: &str = include_str!("../test_vectors.json");
  constant OUTPUT_LEN (line 10) | pub const OUTPUT_LEN: usize = 2 * BLOCK_LEN + 3;
  constant TEST_CASES (line 12) | pub const TEST_CASES: &[usize] = &[
  constant TEST_KEY (line 50) | pub const TEST_KEY: &[u8; blake3::KEY_LEN] = b"whats the Elvish word for...
  constant TEST_CONTEXT (line 51) | pub const TEST_CONTEXT: &str = "BLAKE3 2019-12-27 16:29:52 test vectors ...
  constant COMMENT (line 53) | const COMMENT: &str = r#"
  function paint_test_input (line 69) | pub fn paint_test_input(buf: &mut [u8]) {
  type Cases (line 76) | pub struct Cases {
  type Case (line 84) | pub struct Case {
  function generate_json (line 91) | pub fn generate_json() -> String {
  function parse_test_cases (line 136) | pub fn parse_test_cases() -> Cases {
  function test_reference_impl_all_at_once (line 144) | fn test_reference_impl_all_at_once(
  function test_reference_impl_one_at_a_time (line 170) | fn test_reference_impl_one_at_a_time(
  function test_incremental_all_at_once (line 202) | fn test_incremental_all_at_once(
  function test_incremental_one_at_a_time (line 231) | fn test_incremental_one_at_a_time(
  function test_recursive (line 269) | fn test_recursive(
  function run_test_vectors (line 288) | fn run_test_vectors() {
  function test_checked_in_vectors_up_to_date (line 342) | fn test_checked_in_vectors_up_to_date() {

FILE: third-party/blake3/tools/compiler_version/build.rs
  function main (line 1) | fn main() {

FILE: third-party/blake3/tools/compiler_version/src/main.rs
  function main (line 3) | fn main() {

FILE: third-party/blake3/tools/instruction_set_support/src/main.rs
  function main (line 1) | fn main() {

FILE: third-party/mimalloc/doc/mimalloc-doc.h
  type mi_arena_id_t (line 499) | typedef int mi_arena_id_t;
  type mi_heap_s (line 640) | struct mi_heap_s
  type mi_heap_t (line 646) | typedef struct mi_heap_s mi_heap_t;
  type mi_heap_area_t (line 853) | typedef struct mi_heap_area_s {
  type mi_option_t (line 911) | typedef enum mi_option_e {

FILE: third-party/mimalloc/include/mimalloc-new-delete.h
  function delete (line 34) | void operator delete(void* p) noexcept              { mi_free(p); }
  function noexcept (line 35) | void operator delete[](void* p) noexcept            { mi_free(p); }
  function operator (line 37) | void operator delete  (void* p, const std::nothrow_t&) noexcept { mi_fre...
  function noexcept (line 38) | void operator delete[](void* p, const std::nothrow_t&) noexcept { mi_fre...
  function operator (line 47) | void operator delete  (void* p, std::size_t n) noexcept { mi_free_size(p...
  function noexcept (line 48) | void operator delete[](void* p, std::size_t n) noexcept { mi_free_size(p...
  function operator (line 52) | void operator delete  (void* p, std::align_val_t al) noexcept { mi_free_...
  function noexcept (line 53) | void operator delete[](void* p, std::align_val_t al) noexcept { mi_free_...
  function operator (line 54) | void operator delete  (void* p, std::size_t n, std::align_val_t al) noex...
  function noexcept (line 55) | void operator delete[](void* p, std::size_t n, std::align_val_t al) noex...
  function operator (line 56) | void operator delete  (void* p, std::align_val_t al, const std::nothrow_...
  function noexcept (line 57) | void operator delete[](void* p, std::align_val_t al, const std::nothrow_...

FILE: third-party/mimalloc/include/mimalloc-stats.h
  type mi_stat_count_t (line 17) | typedef struct mi_stat_count_s {
  type mi_stat_counter_t (line 24) | typedef struct mi_stat_counter_s {
  function MI_STAT_COUNT (line 30) | MI_STAT_COUNT(reserved)                   /* reserved memory bytes */ \

FILE: third-party/mimalloc/include/mimalloc.h
  type mi_heap_s (line 188) | struct mi_heap_s
  type mi_heap_t (line 189) | typedef struct mi_heap_s mi_heap_t;
  type mi_heap_area_t (line 256) | typedef struct mi_heap_area_s {
  type mi_arena_id_t (line 284) | typedef int mi_arena_id_t;
  type mi_option_t (line 350) | typedef enum mi_option_e {
  type T (line 477) | typedef T                 value_type;
  type std (line 478) | typedef std::size_t       size_type;
  type std (line 479) | typedef std::ptrdiff_t    difference_type;
  type value_type (line 480) | typedef value_type&       reference;
  type value_type (line 481) | typedef value_type const& const_reference;
  type value_type (line 482) | typedef value_type*       pointer;
  type value_type (line 483) | typedef value_type const* const_pointer;
  function construct (line 492) | void construct(pointer p, value_type const& val) { ::new(p) value_type(v...
  function destroy (line 493) | void destroy(pointer p) { p->~value_type(); }
  function pointer (line 497) | pointer       address(reference x) const        { return &x; }
  function const_pointer (line 498) | const_pointer address(const_reference x) const  { return &x; }
  type mi_stl_allocator (line 505) | typedef mi_stl_allocator<U> other;
  function mi_decl_nodiscard (line 543) | mi_decl_nodiscard T* allocate(size_type count) { return static_cast<T*>(...
  function mi_decl_nodiscard (line 544) | mi_decl_nodiscard T* allocate(size_type count, const void*) { return all...
  function collect (line 553) | void collect(bool force) { mi_heap_collect(this->heap.get(), force); }
  type _mi_heap_stl_allocator_common (line 558) | struct _mi_heap_stl_allocator_common
  function heap (line 564) | _mi_heap_stl_allocator_common(const _mi_heap_stl_allocator_common& x) mi...
  function heap_destroy (line 569) | static void heap_destroy(mi_heap_t* hp) { if (hp != NULL) { mi_heap_dest...
  type mi_heap_stl_allocator (line 581) | typedef mi_heap_stl_allocator<U> other;
  type mi_heap_destroy_stl_allocator (line 598) | typedef mi_heap_destroy_stl_allocator<U> other;

FILE: third-party/mimalloc/include/mimalloc/atomic.h
  function mi_atomic_addi64_relaxed (line 129) | static inline int64_t mi_atomic_addi64_relaxed(volatile int64_t* p, int6...
  function mi_atomic_void_addi64_relaxed (line 132) | static inline void mi_atomic_void_addi64_relaxed(volatile int64_t* p, co...
  function mi_atomic_maxi64_relaxed (line 138) | static inline void mi_atomic_maxi64_relaxed(volatile int64_t* p, int64_t...
  type LONG64 (line 158) | typedef LONG64   msc_intptr_t;
  type LONG (line 161) | typedef LONG     msc_intptr_t;
  type mi_memory_order (line 165) | typedef enum mi_memory_order_e {
  function mi_atomic_fetch_add_explicit (line 174) | static inline uintptr_t mi_atomic_fetch_add_explicit(_Atomic(uintptr_t)*...
  function mi_atomic_fetch_sub_explicit (line 178) | static inline uintptr_t mi_atomic_fetch_sub_explicit(_Atomic(uintptr_t)*...
  function mi_atomic_fetch_and_explicit (line 182) | static inline uintptr_t mi_atomic_fetch_and_explicit(_Atomic(uintptr_t)*...
  function mi_atomic_fetch_or_explicit (line 186) | static inline uintptr_t mi_atomic_fetch_or_explicit(_Atomic(uintptr_t)*p...
  function mi_atomic_compare_exchange_strong_explicit (line 190) | static inline bool mi_atomic_compare_exchange_strong_explicit(_Atomic(ui...
  function mi_atomic_compare_exchange_weak_explicit (line 201) | static inline bool mi_atomic_compare_exchange_weak_explicit(_Atomic(uint...
  function mi_atomic_exchange_explicit (line 204) | static inline uintptr_t mi_atomic_exchange_explicit(_Atomic(uintptr_t)*p...
  function mi_atomic_thread_fence (line 208) | static inline void mi_atomic_thread_fence(mi_memory_order mo) {
  function mi_atomic_load_explicit (line 213) | static inline uintptr_t mi_atomic_load_explicit(_Atomic(uintptr_t) const...
  function mi_atomic_store_explicit (line 225) | static inline void mi_atomic_store_explicit(_Atomic(uintptr_t)*p, uintpt...
  function mi_atomic_loadi64_explicit (line 233) | static inline int64_t mi_atomic_loadi64_explicit(_Atomic(int64_t)*p, mi_...
  function mi_atomic_storei64_explicit (line 246) | static inline void mi_atomic_storei64_explicit(_Atomic(int64_t)*p, int64...
  function mi_atomic_addi64_relaxed (line 256) | static inline int64_t mi_atomic_addi64_relaxed(volatile _Atomic(int64_t)...
  function mi_atomic_void_addi64_relaxed (line 270) | static inline void mi_atomic_void_addi64_relaxed(volatile int64_t* p, co...
  function mi_atomic_maxi64_relaxed (line 277) | static inline void mi_atomic_maxi64_relaxed(volatile _Atomic(int64_t)*p,...
  function mi_atomic_addi64_acq_rel (line 284) | static inline void mi_atomic_addi64_acq_rel(volatile _Atomic(int64_t*)p,...
  function mi_atomic_casi64_strong_acq_rel (line 288) | static inline bool mi_atomic_casi64_strong_acq_rel(volatile _Atomic(int6...
  function mi_atomic_addi (line 321) | static inline intptr_t mi_atomic_addi(_Atomic(intptr_t)*p, intptr_t add) {
  function mi_atomic_subi (line 326) | static inline intptr_t mi_atomic_subi(_Atomic(intptr_t)*p, intptr_t sub) {
  type mi_atomic_once_t (line 335) | typedef _Atomic(uintptr_t) mi_atomic_once_t;
  function mi_atomic_once (line 338) | static inline bool mi_atomic_once( mi_atomic_once_t* once ) {
  type mi_atomic_guard_t (line 344) | typedef _Atomic(uintptr_t) mi_atomic_guard_t;
  function mi_atomic_yield (line 361) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 365) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 370) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 377) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 381) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 385) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 390) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 394) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 399) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 406) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 411) | static inline void mi_atomic_yield(void) {
  function mi_atomic_yield (line 416) | static inline void mi_atomic_yield(void) {
  function mi_lock_try_acquire (line 439) | static inline bool mi_lock_try_acquire(mi_lock_t* lock) {
  function mi_lock_acquire (line 442) | static inline void mi_lock_acquire(mi_lock_t* lock) {
  function mi_lock_release (line 445) | static inline void mi_lock_release(mi_lock_t* lock) {
  function mi_lock_init (line 448) | static inline void mi_lock_init(mi_lock_t* lock) {
  function mi_lock_done (line 451) | static inline void mi_lock_done(mi_lock_t* lock) {
  function mi_lock_try_acquire (line 458) | static inline bool mi_lock_try_acquire(mi_lock_t* lock) {
  function mi_lock_acquire (line 461) | static inline void mi_lock_acquire(mi_lock_t* lock) {
  function mi_lock_release (line 464) | static inline void mi_lock_release(mi_lock_t* lock) {
  function mi_lock_init (line 467) | static inline void mi_lock_init(mi_lock_t* lock) {
  function mi_lock_done (line 470) | static inline void mi_lock_done(mi_lock_t* lock) {
  function mi_lock_try_acquire (line 482) | static inline bool mi_lock_try_acquire(mi_lock_t* lock) {
  function mi_lock_acquire (line 485) | static inline void mi_lock_acquire(mi_lock_t* lock) {
  function mi_lock_release (line 491) | static inline void mi_lock_release(mi_lock_t* lock) {
  function mi_lock_init (line 494) | static inline void mi_lock_init(mi_lock_t* lock) {
  function mi_lock_done (line 497) | static inline void mi_lock_done(mi_lock_t* lock) {
  function mi_lock_try_acquire (line 506) | static inline bool mi_lock_try_acquire(mi_lock_t* lock) {
  function mi_lock_acquire (line 509) | static inline void mi_lock_acquire(mi_lock_t* lock) {
  function mi_lock_release (line 512) | static inline void mi_lock_release(mi_lock_t* lock) {
  function mi_lock_init (line 515) | static inline void mi_lock_init(mi_lock_t* lock) {
  function mi_lock_done (line 518) | static inline void mi_lock_done(mi_lock_t* lock) {
  function mi_lock_try_acquire (line 529) | static inline bool mi_lock_try_acquire(mi_lock_t* lock) {
  function mi_lock_acquire (line 533) | static inline void mi_lock_acquire(mi_lock_t* lock) {
  function mi_lock_release (line 539) | static inline void mi_lock_release(mi_lock_t* lock) {
  function mi_lock_init (line 542) | static inline void mi_lock_init(mi_lock_t* lock) {
  function mi_lock_done (line 545) | static inline void mi_lock_done(mi_lock_t* lock) {

FILE: third-party/mimalloc/include/mimalloc/internal.h
  type mi_arena_field_cursor_t (line 161) | typedef struct mi_arena_field_cursor_s { // abstract struct
  function _mi_is_power_of_two (line 324) | static inline bool _mi_is_power_of_two(uintptr_t x) {
  function _mi_is_aligned (line 329) | static inline bool _mi_is_aligned(void* p, size_t alignment) {
  function _mi_align_up (line 335) | static inline uintptr_t _mi_align_up(uintptr_t sz, size_t alignment) {
  function _mi_align_down (line 347) | static inline uintptr_t _mi_align_down(uintptr_t sz, size_t alignment) {
  function _mi_divide_up (line 370) | static inline uintptr_t _mi_divide_up(uintptr_t size, size_t divider) {
  function _mi_clamp (line 377) | static inline size_t _mi_clamp(size_t sz, size_t min, size_t max) {
  function mi_mem_is_zero (line 384) | static inline bool mi_mem_is_zero(const void* p, size_t size) {
  function _mi_wsize_from_size (line 394) | static inline size_t _mi_wsize_from_size(size_t size) {
  function mi_mul_overflow (line 405) | static inline bool mi_mul_overflow(size_t count, size_t size, size_t* to...
  function mi_mul_overflow (line 415) | static inline bool mi_mul_overflow(size_t count, size_t size, size_t* to...
  function mi_count_size_overflow (line 424) | static inline bool mi_count_size_overflow(size_t count, size_t size, siz...
  function mi_heap_is_backing (line 446) | static inline bool mi_heap_is_backing(const mi_heap_t* heap) {
  function mi_heap_is_initialized (line 450) | static inline bool mi_heap_is_initialized(mi_heap_t* heap) {
  function _mi_ptr_cookie (line 455) | static inline uintptr_t _mi_ptr_cookie(const void* p) {
  function mi_page_t (line 465) | static inline mi_page_t* _mi_heap_get_free_small_page(mi_heap_t* heap, s...
  function mi_segment_t (line 477) | static inline mi_segment_t* _mi_ptr_segment(const void* p) {
  function mi_page_t (line 486) | static inline mi_page_t* mi_slice_to_page(mi_slice_t* s) {
  function mi_slice_t (line 491) | static inline mi_slice_t* mi_page_to_slice(mi_page_t* p) {
  function mi_segment_t (line 497) | static inline mi_segment_t* _mi_page_segment(const mi_page_t* page) {
  function mi_slice_t (line 504) | static inline mi_slice_t* mi_slice_first(const mi_slice_t* slice) {
  function mi_page_t (line 513) | static inline mi_page_t* _mi_segment_page_of(const mi_segment_t* segment...
  function mi_page_t (line 534) | static inline mi_page_t* _mi_ptr_page(void* p) {
  function mi_page_block_size (line 540) | static inline size_t mi_page_block_size(const mi_page_t* page) {
  function mi_page_is_huge (line 545) | static inline bool mi_page_is_huge(const mi_page_t* page) {
  function mi_page_usable_block_size (line 553) | static inline size_t mi_page_usable_block_size(const mi_page_t* page) {
  function mi_segment_size (line 558) | static inline size_t mi_segment_size(mi_segment_t* segment) {
  function mi_block_t (line 567) | static inline mi_block_t* mi_page_thread_free(const mi_page_t* page) {
  function mi_delayed_t (line 571) | static inline mi_delayed_t mi_page_thread_free_flag(const mi_page_t* pag...
  function mi_heap_t (line 576) | static inline mi_heap_t* mi_page_heap(const mi_page_t* page) {
  function mi_page_set_heap (line 580) | static inline void mi_page_set_heap(mi_page_t* page, mi_heap_t* heap) {
  function mi_block_t (line 587) | static inline mi_block_t* mi_tf_block(mi_thread_free_t tf) {
  function mi_delayed_t (line 590) | static inline mi_delayed_t mi_tf_delayed(mi_thread_free_t tf) {
  function mi_thread_free_t (line 593) | static inline mi_thread_free_t mi_tf_make(mi_block_t* block, mi_delayed_...
  function mi_thread_free_t (line 596) | static inline mi_thread_free_t mi_tf_set_delayed(mi_thread_free_t tf, mi...
  function mi_thread_free_t (line 599) | static inline mi_thread_free_t mi_tf_set_block(mi_thread_free_t tf, mi_b...
  function mi_page_all_free (line 605) | static inline bool mi_page_all_free(const mi_page_t* page) {
  function mi_page_has_any_available (line 611) | static inline bool mi_page_has_any_available(const mi_page_t* page) {
  function mi_page_immediate_available (line 617) | static inline bool mi_page_immediate_available(const mi_page_t* page) {
  function mi_page_is_mostly_used (line 623) | static inline bool mi_page_is_mostly_used(const mi_page_t* page) {
  function mi_page_queue_t (line 629) | static inline mi_page_queue_t* mi_page_queue(const mi_heap_t* heap, size...
  function mi_page_is_in_full (line 638) | static inline bool mi_page_is_in_full(const mi_page_t* page) {
  function mi_page_set_in_full (line 642) | static inline void mi_page_set_in_full(mi_page_t* page, bool in_full) {
  function mi_page_has_aligned (line 646) | static inline bool mi_page_has_aligned(const mi_page_t* page) {
  function mi_page_set_has_aligned (line 650) | static inline void mi_page_set_has_aligned(mi_page_t* page, bool has_ali...
  function mi_block_ptr_is_guarded (line 658) | static inline bool mi_block_ptr_is_guarded(const mi_block_t* block, cons...
  function mi_heap_malloc_use_guarded (line 663) | static inline bool mi_heap_malloc_use_guarded(mi_heap_t* heap, size_t si...
  function mi_is_in_same_segment (line 713) | static inline bool mi_is_in_same_segment(const void* p, const void* q) {
  function mi_is_in_same_page (line 717) | static inline bool mi_is_in_same_page(const void* p, const void* q) {
  function mi_rotl (line 727) | static inline uintptr_t mi_rotl(uintptr_t x, uintptr_t shift) {
  function mi_rotr (line 731) | static inline uintptr_t mi_rotr(uintptr_t x, uintptr_t shift) {
  function mi_encoded_t (line 741) | static inline mi_encoded_t mi_ptr_encode(const void* null, const void* p...
  function mi_ptr_encode_canary (line 746) | static inline uint32_t mi_ptr_encode_canary(const void* null, const void...
  function mi_block_t (line 756) | static inline mi_block_t* mi_block_nextx( const void* null, const mi_blo...
  function mi_block_set_nextx (line 769) | static inline void mi_block_set_nextx(const void* null, mi_block_t* bloc...
  function mi_block_t (line 780) | static inline mi_block_t* mi_block_next(const mi_page_t* page, const mi_...
  function mi_block_set_next (line 796) | static inline void mi_block_set_next(const mi_page_t* page, mi_block_t* ...
  function mi_commit_mask_create_empty (line 810) | static inline void mi_commit_mask_create_empty(mi_commit_mask_t* cm) {
  function mi_commit_mask_create_full (line 816) | static inline void mi_commit_mask_create_full(mi_commit_mask_t* cm) {
  function mi_commit_mask_is_empty (line 822) | static inline bool mi_commit_mask_is_empty(const mi_commit_mask_t* cm) {
  function mi_commit_mask_is_full (line 829) | static inline bool mi_commit_mask_is_full(const mi_commit_mask_t* cm) {
  function mi_memid_t (line 854) | static inline mi_memid_t _mi_memid_create(mi_memkind_t memkind) {
  function mi_memid_t (line 861) | static inline mi_memid_t _mi_memid_none(void) {
  function mi_memid_t (line 865) | static inline mi_memid_t _mi_memid_create_os(bool committed, bool is_zer...
  function _mi_random_shuffle (line 878) | static inline uintptr_t _mi_random_shuffle(uintptr_t x) {
  function _mi_os_numa_node (line 906) | static inline int _mi_os_numa_node(void) {
  function _mi_os_numa_node_count (line 910) | static inline size_t _mi_os_numa_node_count(void) {
  function mi_clz (line 926) | static inline size_t mi_clz(size_t x) {
  function mi_ctz (line 934) | static inline size_t mi_ctz(size_t x) {
  function mi_clz (line 948) | static inline size_t mi_clz(size_t x) {
  function mi_ctz (line 958) | static inline size_t mi_ctz(size_t x) {
  function mi_ctz_generic32 (line 971) | static inline size_t mi_ctz_generic32(uint32_t x) {
  function mi_clz_generic32 (line 981) | static inline size_t mi_clz_generic32(uint32_t x) {
  function mi_ctz (line 996) | static inline size_t mi_ctz(size_t x) {
  function mi_clz (line 1011) | static inline size_t mi_clz(size_t x) {
  function mi_bsr (line 1029) | static inline size_t mi_bsr(size_t x) {
  function _mi_memcpy (line 1046) | static inline void _mi_memcpy(void* dst, const void* src, size_t n) {
  function _mi_memzero (line 1054) | static inline void _mi_memzero(void* dst, size_t n) {
  function _mi_memcpy (line 1063) | static inline void _mi_memcpy(void* dst, const void* src, size_t n) {
  function _mi_memzero (line 1066) | static inline void _mi_memzero(void* dst, size_t n) {
  function _mi_memcpy_aligned (line 1078) | static inline void _mi_memcpy_aligned(void* dst, const void* src, size_t...
  function _mi_memzero_aligned (line 1085) | static inline void _mi_memzero_aligned(void* dst, size_t n) {
  function _mi_memcpy_aligned (line 1092) | static inline void _mi_memcpy_aligned(void* dst, const void* src, size_t...
  function _mi_memzero_aligned (line 1097) | static inline void _mi_memzero_aligned(void* dst, size_t n) {

FILE: third-party/mimalloc/include/mimalloc/prim.h
  type mi_os_mem_config_t (line 24) | typedef struct mi_os_mem_config_s {
  type mi_process_info_t (line 85) | typedef struct mi_process_info_s {
  function mi_prim_tls_slot_set (line 180) | static inline void mi_prim_tls_slot_set(size_t slot, void* value) mi_att...
  function mi_prim_tls_slot_set (line 235) | static inline void mi_prim_tls_slot_set(size_t slot, void* value) mi_att...
  function mi_threadid_t (line 280) | static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept {
  function mi_threadid_t (line 286) | static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept {
  function mi_threadid_t (line 293) | static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept {
  function mi_threadid_t (line 300) | static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept {
  function mi_threadid_t (line 316) | static inline mi_threadid_t _mi_prim_thread_id(void) mi_attr_noexcept {
  function mi_heap_t (line 368) | static inline mi_heap_t* mi_prim_get_default_heap(void) {
  function mi_heap_t (line 383) | static inline mi_heap_t** mi_prim_tls_pthread_heap_slot(void) {
  function mi_heap_t (line 391) | static inline mi_heap_t* mi_prim_get_default_heap(void) {
  function mi_heap_t (line 402) | static inline mi_heap_t* mi_prim_get_default_heap(void) {
  function mi_heap_t (line 409) | static inline mi_heap_t* mi_prim_get_default_heap(void) {

FILE: third-party/mimalloc/include/mimalloc/types.h
  type mi_ssize_t (line 139) | typedef int64_t  mi_ssize_t;
  type mi_ssize_t (line 142) | typedef int32_t  mi_ssize_t;
  type mi_encoded_t (line 240) | typedef uintptr_t  mi_encoded_t;
  type mi_threadid_t (line 243) | typedef size_t     mi_threadid_t;
  type mi_block_t (line 246) | typedef struct mi_block_s {
  type mi_delayed_t (line 259) | typedef enum mi_delayed_e {
  type mi_page_flags_t (line 270) | typedef union mi_page_flags_s {
  type mi_page_flags_t (line 279) | typedef union mi_page_flags_s {
  type mi_thread_free_t (line 290) | typedef uintptr_t mi_thread_free_t;
  type mi_page_t (line 320) | typedef struct mi_page_s {
  type mi_page_kind_t (line 364) | typedef enum mi_page_kind_e {
  type mi_segment_kind_t (line 372) | typedef enum mi_segment_kind_e {
  type mi_commit_mask_t (line 399) | typedef struct mi_commit_mask_s {
  type mi_page_t (line 403) | typedef mi_page_t  mi_slice_t;
  type mi_msecs_t (line 404) | typedef int64_t    mi_msecs_t;
  type mi_memkind_t (line 412) | typedef enum mi_memkind_e {
  function mi_memkind_is_os (line 422) | static inline bool mi_memkind_is_os(mi_memkind_t memkind) {
  type mi_memid_os_info_t (line 426) | typedef struct mi_memid_os_info {
  type mi_memid_arena_info_t (line 431) | typedef struct mi_memid_arena_info {
  type mi_memid_t (line 437) | typedef struct mi_memid_s {
  type mi_subproc_t (line 463) | typedef struct mi_subproc_s mi_subproc_t;
  type mi_segment_t (line 465) | typedef struct mi_segment_s {
  type mi_tld_t (line 517) | typedef struct mi_tld_s mi_tld_t;
  type mi_page_queue_t (line 520) | typedef struct mi_page_queue_s {
  type mi_random_ctx_t (line 529) | typedef struct mi_random_cxt_s {
  type mi_padding_t (line 539) | typedef struct mi_padding_s {
  type mi_heap_s (line 554) | struct mi_heap_s {
  type mi_subproc_s (line 588) | struct mi_subproc_s {
  type mi_span_queue_t (line 605) | typedef struct mi_span_queue_s {
  type mi_segments_tld_t (line 614) | typedef struct mi_segments_tld_s {
  type mi_tld_s (line 626) | struct mi_tld_s {

FILE: third-party/mimalloc/src/alloc-aligned.c
  function mi_malloc_is_naturally_aligned (line 18) | static bool mi_malloc_is_naturally_aligned( size_t size, size_t alignmen...
  function mi_decl_restrict (line 28) | static mi_decl_restrict void* mi_heap_malloc_guarded_aligned(mi_heap_t* ...
  function mi_decl_noinline (line 55) | static mi_decl_noinline void* mi_heap_malloc_zero_aligned_at_overalloc(m...
  function mi_decl_noinline (line 135) | static mi_decl_noinline void* mi_heap_malloc_zero_aligned_at_generic(mi_...
  function mi_likely (line 153) | mi_likely(is_aligned_or_null) {
  function mi_likely (line 192) | mi_likely(is_aligned)
  function mi_decl_nodiscard (line 311) | mi_decl_nodiscard void* mi_heap_realloc_aligned_at(mi_heap_t* heap, void...
  function mi_decl_nodiscard (line 315) | mi_decl_nodiscard void* mi_heap_realloc_aligned(mi_heap_t* heap, void* p...
  function mi_decl_nodiscard (line 319) | mi_decl_nodiscard void* mi_heap_rezalloc_aligned_at(mi_heap_t* heap, voi...
  function mi_decl_nodiscard (line 323) | mi_decl_nodiscard void* mi_heap_rezalloc_aligned(mi_heap_t* heap, void* ...
  function mi_decl_nodiscard (line 327) | mi_decl_nodiscard void* mi_heap_recalloc_aligned_at(mi_heap_t* heap, voi...
  function mi_decl_nodiscard (line 333) | mi_decl_nodiscard void* mi_heap_recalloc_aligned(mi_heap_t* heap, void* ...
  function mi_decl_nodiscard (line 339) | mi_decl_nodiscard void* mi_realloc_aligned_at(void* p, size_t newsize, s...
  function mi_decl_nodiscard (line 343) | mi_decl_nodiscard void* mi_realloc_aligned(void* p, size_t newsize, size...
  function mi_decl_nodiscard (line 347) | mi_decl_nodiscard void* mi_rezalloc_aligned_at(void* p, size_t newsize, ...
  function mi_decl_nodiscard (line 351) | mi_decl_nodiscard void* mi_rezalloc_aligned(void* p, size_t newsize, siz...
  function mi_decl_nodiscard (line 355) | mi_decl_nodiscard void* mi_recalloc_aligned_at(void* p, size_t newcount,...
  function mi_decl_nodiscard (line 359) | mi_decl_nodiscard void* mi_recalloc_aligned(void* p, size_t newcount, si...

FILE: third-party/mimalloc/src/alloc-override.c
  function mi_decl_externc (line 60) | mi_decl_externc size_t mi_malloc_size_checked(void *p) {
  type mi_interpose_s (line 67) | struct mi_interpose_s {
  type mi_interpose_s (line 74) | struct mi_interpose_s
  type mi_interpose_s (line 117) | struct mi_interpose_s
  function void (line 165) | void operator delete(void* p) noexcept              MI_FORWARD0(mi_free,p)
  function operator (line 181) | void operator delete  (void* p, std::align_val_t al) noexcept { mi_free_...
  function noexcept (line 182) | void operator delete[](void* p, std::align_val_t al) noexcept { mi_free_...
  function operator (line 183) | void operator delete  (void* p, std::size_t n, std::align_val_t al) noex...
  function noexcept (line 184) | void operator delete[](void* p, std::size_t n, std::align_val_t al) noex...
  function operator (line 185) | void operator delete  (void* p, std::align_val_t al, const std::nothrow_...
  function noexcept (line 186) | void operator delete[](void* p, std::align_val_t al, const std::nothrow_...
  function _ZdlPv (line 201) | void _ZdlPv(void* p)            MI_FORWARD0(mi_free,p) // delete
  function _ZdaPvSt11align_val_t (line 207) | void _ZdaPvSt11align_val_t(void* p, size_t al)            { mi_free_alig...
  function _ZdlPvmSt11align_val_t (line 208) | void _ZdlPvmSt11align_val_t(void* p, size_t n, size_t al) { mi_free_size...
  function _ZdaPvmSt11align_val_t (line 209) | void _ZdaPvmSt11align_val_t(void* p, size_t n, size_t al) { mi_free_size...
  function _ZdlPvRKSt9nothrow_t (line 211) | void _ZdlPvRKSt9nothrow_t(void* p, mi_nothrow_t tag)      { MI_UNUSED(ta...
  function _ZdaPvRKSt9nothrow_t (line 212) | void _ZdaPvRKSt9nothrow_t(void* p, mi_nothrow_t tag)      { MI_UNUSED(ta...
  function _ZdlPvSt11align_val_tRKSt9nothrow_t (line 213) | void _ZdlPvSt11align_val_tRKSt9nothrow_t(void* p, size_t al, mi_nothrow_...
  function _ZdaPvSt11align_val_tRKSt9nothrow_t (line 214) | void _ZdaPvSt11align_val_tRKSt9nothrow_t(void* p, size_t al, mi_nothrow_...
  function vfree (line 259) | void   vfree(void* p)                    { mi_free(p); }
  function malloc_good_size (line 260) | size_t malloc_good_size(size_t size)     { return mi_malloc_good_size(si...
  function posix_memalign (line 261) | int    posix_memalign(void** p, size_t alignment, size_t size) { return ...
  function cfree (line 276) | void  cfree(void* p)                                    { mi_free(p); }
  function mi_decl_weak (line 282) | mi_decl_weak int reallocarr(void* p, size_t count, size_t size)    { ret...
  function __posix_memalign (line 303) | int   __posix_memalign(void** p, size_t alignment, size_t size) { return...

FILE: third-party/mimalloc/src/alloc-posix.c
  function mi_decl_nodiscard (line 35) | mi_decl_nodiscard size_t mi_malloc_size(const void* p) mi_attr_noexcept {
  function mi_decl_nodiscard (line 40) | mi_decl_nodiscard size_t mi_malloc_usable_size(const void *p) mi_attr_no...
  function mi_decl_nodiscard (line 45) | mi_decl_nodiscard size_t mi_malloc_good_size(size_t size) mi_attr_noexce...
  function mi_cfree (line 49) | void mi_cfree(void* p) mi_attr_noexcept {
  function mi_posix_memalign (line 55) | int mi_posix_memalign(void** p, size_t alignment, size_t size) mi_attr_n...
  function mi_decl_nodiscard (line 102) | mi_decl_nodiscard void* mi_reallocarray( void* p, size_t count, size_t s...
  function mi_decl_nodiscard (line 108) | mi_decl_nodiscard int mi_reallocarr( void* p, size_t count, size_t size ...
  function mi_dupenv_s (line 143) | int mi_dupenv_s(char** buf, size_t* size, const char* name) mi_attr_noex...
  function mi_wdupenv_s (line 158) | int mi_wdupenv_s(unsigned short** buf, size_t* size, const unsigned shor...
  function mi_decl_nodiscard (line 179) | mi_decl_nodiscard void* mi_aligned_offset_recalloc(void* p, size_t newco...
  function mi_decl_nodiscard (line 183) | mi_decl_nodiscard void* mi_aligned_recalloc(void* p, size_t newcount, si...

FILE: third-party/mimalloc/src/alloc.c
  function mi_unlikely (line 60) | mi_unlikely(zero) {
  function mi_decl_restrict (line 128) | static inline mi_decl_restrict void* mi_heap_malloc_small_zero(mi_heap_t...
  function else (line 180) | else if (huge_alignment==0 && mi_heap_malloc_use_guarded(heap,size)) {
  function mi_decl_nodiscard (line 299) | mi_decl_nodiscard void* mi_heap_realloc(mi_heap_t* heap, void* p, size_t...
  function mi_decl_nodiscard (line 303) | mi_decl_nodiscard void* mi_heap_reallocn(mi_heap_t* heap, void* p, size_...
  function mi_decl_nodiscard (line 311) | mi_decl_nodiscard void* mi_heap_reallocf(mi_heap_t* heap, void* p, size_...
  function mi_decl_nodiscard (line 317) | mi_decl_nodiscard void* mi_heap_rezalloc(mi_heap_t* heap, void* p, size_...
  function mi_decl_nodiscard (line 321) | mi_decl_nodiscard void* mi_heap_recalloc(mi_heap_t* heap, void* p, size_...
  function mi_decl_nodiscard (line 328) | mi_decl_nodiscard void* mi_realloc(void* p, size_t newsize) mi_attr_noex...
  function mi_decl_nodiscard (line 332) | mi_decl_nodiscard void* mi_reallocn(void* p, size_t count, size_t size) ...
  function mi_decl_nodiscard (line 337) | mi_decl_nodiscard void* mi_reallocf(void* p, size_t newsize) mi_attr_noe...
  function mi_decl_nodiscard (line 341) | mi_decl_nodiscard void* mi_rezalloc(void* p, size_t newsize) mi_attr_noe...
  function mi_decl_nodiscard (line 345) | mi_decl_nodiscard void* mi_recalloc(void* p, size_t count, size_t size) ...
  function mi_try_new_handler (line 467) | static bool mi_try_new_handler(bool nothrow) {
  function std_new_handler_t (line 494) | std_new_handler_t __attribute__((weak)) _ZSt15get_new_handlerv(void) {
  function std_new_handler_t (line 497) | static std_new_handler_t mi_get_new_handler(void) {
  function std_new_handler_t (line 502) | static std_new_handler_t mi_get_new_handler() {
  function mi_try_new_handler (line 507) | static bool mi_try_new_handler(bool nothrow) {
  function mi_decl_noinline (line 531) | static mi_decl_noinline void* mi_try_new(size_t size, bool nothrow) {
  function mi_decl_nodiscard (line 587) | mi_decl_nodiscard void* mi_new_realloc(void* p, size_t newsize) {
  function mi_decl_nodiscard (line 595) | mi_decl_nodiscard void* mi_new_reallocn(void* p, size_t newcount, size_t...
  function mi_decl_restrict (line 649) | mi_decl_restrict void* _mi_heap_malloc_guarded(mi_heap_t* heap, size_t s...

FILE: third-party/mimalloc/src/arena-abandon.c
  function mi_arena_segment_os_clear_abandoned (line 51) | static bool mi_arena_segment_os_clear_abandoned(mi_segment_t* segment, b...
  function _mi_arena_segment_clear_abandoned (line 94) | bool _mi_arena_segment_clear_abandoned(mi_segment_t* segment) {
  function mi_arena_segment_os_mark_abandoned (line 119) | static void mi_arena_segment_os_mark_abandoned(mi_segment_t* segment) {
  function _mi_arena_segment_mark_abandoned (line 143) | void _mi_arena_segment_mark_abandoned(mi_segment_t* segment)
  function _mi_arena_field_cursor_init (line 172) | void _mi_arena_field_cursor_init(mi_heap_t* heap, mi_subproc_t* subproc,...
  function _mi_arena_field_cursor_done (line 202) | void _mi_arena_field_cursor_done(mi_arena_field_cursor_t* current) {
  function mi_segment_t (line 209) | static mi_segment_t* mi_arena_segment_clear_abandoned_at(mi_arena_t* are...
  function mi_segment_t (line 232) | static mi_segment_t* mi_arena_segment_clear_abandoned_next_field(mi_aren...
  function mi_segment_t (line 282) | static mi_segment_t* mi_arena_segment_clear_abandoned_next_list(mi_arena...
  function mi_segment_t (line 317) | mi_segment_t* _mi_arena_segment_clear_abandoned_next(mi_arena_field_curs...
  function mi_abandoned_visit_blocks (line 329) | bool mi_abandoned_visit_blocks(mi_subproc_id_t subproc_id, int heap_tag,...

FILE: third-party/mimalloc/src/arena.c
  type mi_arena_t (line 33) | typedef struct mi_arena_s {
  function mi_arena_id_index (line 75) | size_t mi_arena_id_index(mi_arena_id_t id) {
  function mi_arena_id_t (line 79) | static mi_arena_id_t mi_arena_id_create(size_t arena_index) {
  function mi_arena_id_t (line 84) | mi_arena_id_t _mi_arena_id_none(void) {
  function mi_arena_id_is_suitable (line 88) | static bool mi_arena_id_is_suitable(mi_arena_id_t arena_id, bool arena_i...
  function _mi_arena_memid_is_suitable (line 93) | bool _mi_arena_memid_is_suitable(mi_memid_t memid, mi_arena_id_t request...
  function _mi_arena_memid_is_os_allocated (line 102) | bool _mi_arena_memid_is_os_allocated(mi_memid_t memid) {
  function mi_arena_get_count (line 106) | size_t mi_arena_get_count(void) {
  function mi_arena_t (line 110) | mi_arena_t* mi_arena_from_index(size_t idx) {
  function mi_block_count_of_size (line 121) | static size_t mi_block_count_of_size(size_t size) {
  function mi_arena_block_size (line 125) | static size_t mi_arena_block_size(size_t bcount) {
  function mi_arena_size (line 129) | static size_t mi_arena_size(mi_arena_t* arena) {
  function mi_memid_t (line 133) | static mi_memid_t mi_memid_create_arena(mi_arena_id_t id, bool is_exclus...
  function mi_arena_memid_indices (line 141) | bool mi_arena_memid_indices(mi_memid_t memid, size_t* arena_index, mi_bi...
  function _mi_arena_meta_free (line 206) | void _mi_arena_meta_free(void* p, mi_memid_t memid, size_t size) {
  function mi_arena_try_claim (line 225) | static bool mi_arena_try_claim(mi_arena_t* arena, size_t blocks, mi_bitm...
  function mi_decl_noinline (line 240) | static mi_decl_noinline void* mi_arena_try_alloc_at(mi_arena_t* arena, s...
  function mi_decl_noinline (line 323) | static mi_decl_noinline void* mi_arena_try_alloc(int numa_node, size_t s...
  function mi_arena_reserve (line 358) | static bool mi_arena_reserve(size_t req_size, bool allow_large, mi_arena...
  function mi_arena_purge_delay (line 457) | static long mi_arena_purge_delay(void) {
  function mi_arena_purge (line 464) | static void mi_arena_purge(mi_arena_t* arena, size_t bitmap_idx, size_t ...
  function mi_arena_schedule_purge (line 494) | static void mi_arena_schedule_purge(mi_arena_t* arena, size_t bitmap_idx...
  function mi_arena_purge_range (line 522) | static bool mi_arena_purge_range(mi_arena_t* arena, size_t idx, size_t s...
  function mi_arena_try_purge (line 546) | static bool mi_arena_try_purge(mi_arena_t* arena, mi_msecs_t now, bool f...
  function mi_arenas_try_purge (line 605) | static void mi_arenas_try_purge( bool force, bool visit_all )
  function _mi_arena_free (line 649) | void _mi_arena_free(void* p, size_t size, size_t committed_size, mi_memi...
  function mi_arenas_unsafe_destroy (line 731) | static void mi_arenas_unsafe_destroy(void) {
  function _mi_arenas_collect (line 755) | void _mi_arenas_collect(bool force_purge) {
  function _mi_arena_unsafe_destroy_all (line 761) | void _mi_arena_unsafe_destroy_all(void) {
  function _mi_arena_contains (line 767) | bool _mi_arena_contains(const void* p) {
  function mi_arena_add (line 782) | static bool mi_arena_add(mi_arena_t* arena, mi_arena_id_t* arena_id, mi_...
  function mi_manage_os_memory_ex2 (line 800) | static bool mi_manage_os_memory_ex2(void* start, size_t size, bool is_la...
  function mi_manage_os_memory_ex (line 866) | bool mi_manage_os_memory_ex(void* start, size_t size, bool is_committed,...
  function mi_reserve_os_memory_ex (line 875) | int mi_reserve_os_memory_ex(size_t size, bool commit, bool allow_large, ...
  function mi_manage_os_memory (line 893) | bool mi_manage_os_memory(void* start, size_t size, bool is_committed, bo...
  function mi_reserve_os_memory (line 898) | int mi_reserve_os_memory(size_t size, bool commit, bool allow_large) mi_...
  function mi_debug_show_bitmap (line 907) | static size_t mi_debug_show_bitmap(const char* prefix, const char* heade...
  function mi_debug_show_arenas (line 931) | void mi_debug_show_arenas(void) mi_attr_noexcept {
  function mi_arenas_print (line 960) | void mi_arenas_print(void) mi_attr_noexcept {
  function mi_reserve_huge_os_pages_at_ex (line 969) | int mi_reserve_huge_os_pages_at_ex(size_t pages, int numa_node, size_t t...
  function mi_reserve_huge_os_pages_at (line 991) | int mi_reserve_huge_os_pages_at(size_t pages, int numa_node, size_t time...
  function mi_reserve_huge_os_pages_interleave (line 996) | int mi_reserve_huge_os_pages_interleave(size_t pages, size_t numa_nodes,...
  function mi_reserve_huge_os_pages (line 1023) | int mi_reserve_huge_os_pages(size_t pages, double max_secs, size_t* page...

FILE: third-party/mimalloc/src/bitmap.c
  function mi_bitmap_mask_ (line 28) | static inline size_t mi_bitmap_mask_(size_t count, size_t bitidx) {
  function _mi_bitmap_try_find_claim_field (line 43) | inline bool _mi_bitmap_try_find_claim_field(mi_bitmap_t bitmap, size_t i...
  function _mi_bitmap_try_find_from_claim (line 100) | bool _mi_bitmap_try_find_from_claim(mi_bitmap_t bitmap, const size_t bit...
  function _mi_bitmap_try_find_from_claim_pred (line 112) | bool _mi_bitmap_try_find_from_claim_pred(mi_bitmap_t bitmap, const size_...
  function _mi_bitmap_unclaim (line 132) | bool _mi_bitmap_unclaim(mi_bitmap_t bitmap, size_t bitmap_fields, size_t...
  function _mi_bitmap_claim (line 145) | bool _mi_bitmap_claim(mi_bitmap_t bitmap, size_t bitmap_fields, size_t c...
  function mi_bitmap_is_claimedx (line 157) | static bool mi_bitmap_is_claimedx(mi_bitmap_t bitmap, size_t bitmap_fiel...
  function _mi_bitmap_try_claim (line 169) | bool _mi_bitmap_try_claim(mi_bitmap_t bitmap, size_t bitmap_fields, size...
  function _mi_bitmap_is_claimed (line 184) | bool _mi_bitmap_is_claimed(mi_bitmap_t bitmap, size_t bitmap_fields, siz...
  function _mi_bitmap_is_any_claimed (line 188) | bool _mi_bitmap_is_any_claimed(mi_bitmap_t bitmap, size_t bitmap_fields,...
  function mi_bitmap_try_find_claim_field_across (line 203) | static bool mi_bitmap_try_find_claim_field_across(mi_bitmap_t bitmap, si...
  function _mi_bitmap_try_find_from_claim_across (line 295) | bool _mi_bitmap_try_find_from_claim_across(mi_bitmap_t bitmap, const siz...
  function mi_bitmap_mask_across (line 323) | static size_t mi_bitmap_mask_across(mi_bitmap_index_t bitmap_idx, size_t...
  function _mi_bitmap_unclaim_across (line 349) | bool _mi_bitmap_unclaim_across(mi_bitmap_t bitmap, size_t bitmap_fields,...
  function _mi_bitmap_claim_across (line 372) | bool _mi_bitmap_claim_across(mi_bitmap_t bitmap, size_t bitmap_fields, s...
  function mi_bitmap_is_claimedx_across (line 401) | static bool mi_bitmap_is_claimedx_across(mi_bitmap_t bitmap, size_t bitm...
  function _mi_bitmap_is_claimed_across (line 427) | bool _mi_bitmap_is_claimed_across(mi_bitmap_t bitmap, size_t bitmap_fiel...
  function _mi_bitmap_is_any_claimed_across (line 431) | bool _mi_bitmap_is_any_claimed_across(mi_bitmap_t bitmap, size_t bitmap_...

FILE: third-party/mimalloc/src/bitmap.h
  type mi_bitmap_field_t (line 31) | typedef _Atomic(size_t)  mi_bitmap_field_t;
  type mi_bitmap_field_t (line 32) | typedef mi_bitmap_field_t*  mi_bitmap_t;
  type mi_bitmap_index_t (line 35) | typedef size_t mi_bitmap_index_t;
  function mi_bitmap_index_t (line 38) | static inline mi_bitmap_index_t mi_bitmap_index_create_ex(size_t idx, si...
  function mi_bitmap_index_t (line 42) | static inline mi_bitmap_index_t mi_bitmap_index_create(size_t idx, size_...
  function mi_bitmap_index_t (line 48) | static inline mi_bitmap_index_t mi_bitmap_index_create_from_bit(size_t f...
  function mi_bitmap_index_field (line 53) | static inline size_t mi_bitmap_index_field(mi_bitmap_index_t bitmap_idx) {
  function mi_bitmap_index_bit_in_field (line 58) | static inline size_t mi_bitmap_index_bit_in_field(mi_bitmap_index_t bitm...
  function mi_bitmap_index_bit (line 63) | static inline size_t mi_bitmap_index_bit(mi_bitmap_index_t bitmap_idx) {

FILE: third-party/mimalloc/src/free.c
  function mi_free_block_local (line 31) | static inline void mi_free_block_local(mi_page_t* page, mi_block_t* bloc...
  function mi_block_t (line 59) | mi_block_t* _mi_page_ptr_unalign(const mi_page_t* page, const void* p) {
  function mi_block_check_unguard (line 77) | static inline void mi_block_check_unguard(mi_page_t* page, mi_block_t* b...
  function mi_block_check_unguard (line 81) | static inline void mi_block_check_unguard(mi_page_t* page, mi_block_t* b...
  function mi_free_generic_local (line 87) | static void mi_decl_noinline mi_free_generic_local(mi_page_t* page, mi_s...
  function mi_free_generic_mt (line 95) | static void mi_decl_noinline mi_free_generic_mt(mi_page_t* page, mi_segm...
  function _mi_free_generic (line 102) | void mi_decl_noinline _mi_free_generic(mi_segment_t* segment, mi_page_t*...
  function mi_segment_t (line 110) | static inline mi_segment_t* mi_checked_ptr_segment(const void* p, const ...
  function _mi_free_delayed_block (line 177) | bool _mi_free_delayed_block(mi_block_t* block) {
  function mi_free_block_delayed_mt (line 209) | static void mi_decl_noinline mi_free_block_delayed_mt( mi_page_t* page, ...
  function mi_free_block_mt (line 253) | static void mi_decl_noinline mi_free_block_mt(mi_page_t* page, mi_segmen...
  function mi_page_usable_aligned_size_of (line 312) | static size_t mi_decl_noinline mi_page_usable_aligned_size_of(const mi_p...
  function _mi_usable_size (line 326) | static inline size_t _mi_usable_size(const void* p, const char* msg) mi_...
  function mi_decl_nodiscard (line 340) | mi_decl_nodiscard size_t mi_usable_size(const void* p) mi_attr_noexcept {
  function mi_free_size (line 349) | void mi_free_size(void* p, size_t size) mi_attr_noexcept {
  function mi_free_size_aligned (line 355) | void mi_free_size_aligned(void* p, size_t size, size_t alignment) mi_att...
  function mi_free_aligned (line 361) | void mi_free_aligned(void* p, size_t alignment) mi_attr_noexcept {
  function mi_list_contains (line 375) | static bool mi_list_contains(const mi_page_t* page, const mi_block_t* li...
  function mi_decl_noinline (line 383) | static mi_decl_noinline bool mi_check_is_double_freex(const mi_page_t* p...
  function mi_check_is_double_free (line 398) | static inline bool mi_check_is_double_free(const mi_page_t* page, const ...
  function mi_check_is_double_free (line 411) | static inline bool mi_check_is_double_free(const mi_page_t* page, const ...
  function mi_page_decode_padding (line 424) | static bool mi_page_decode_padding(const mi_page_t* page, const mi_block...
  function mi_page_usable_size_of (line 439) | static size_t mi_page_usable_size_of(const mi_page_t* page, const mi_blo...
  function _mi_padding_shrink (line 451) | void _mi_padding_shrink(const mi_page_t* page, const mi_block_t* block, ...
  function mi_page_usable_size_of (line 467) | static size_t mi_page_usable_size_of(const mi_page_t* page, const mi_blo...
  function _mi_padding_shrink (line 472) | void _mi_padding_shrink(const mi_page_t* page, const mi_block_t* block, ...
  function mi_verify_padding (line 481) | static bool mi_verify_padding(const mi_page_t* page, const mi_block_t* b...
  function mi_check_padding (line 505) | static void mi_check_padding(const mi_page_t* page, const mi_block_t* bl...
  function mi_check_padding (line 515) | static void mi_check_padding(const mi_page_t* page, const mi_block_t* bl...
  function mi_stat_free (line 524) | static void mi_stat_free(const mi_page_t* page, const mi_block_t* block) {
  function mi_stat_free (line 548) | static void mi_stat_free(const mi_page_t* page, const mi_block_t* block) {
  function mi_block_unguard (line 556) | static void mi_block_unguard(mi_page_t* page, mi_block_t* block, void* p) {

FILE: third-party/mimalloc/src/heap.c
  function mi_heap_visit_pages (line 27) | static bool mi_heap_visit_pages(mi_heap_t* heap, heap_page_visitor_fun* ...
  function mi_heap_page_is_valid (line 56) | static bool mi_heap_page_is_valid(mi_heap_t* heap, mi_page_queue_t* pq, ...
  function mi_heap_is_valid (line 68) | static bool mi_heap_is_valid(mi_heap_t* heap) {
  type mi_collect_t (line 85) | typedef enum mi_collect_e {
  function mi_heap_page_collect (line 92) | static bool mi_heap_page_collect(mi_heap_t* heap, mi_page_queue_t* pq, m...
  function mi_heap_page_never_delayed_free (line 115) | static bool mi_heap_page_never_delayed_free(mi_heap_t* heap, mi_page_que...
  function mi_heap_collect_ex (line 124) | static void mi_heap_collect_ex(mi_heap_t* heap, mi_collect_t collect)
  function _mi_heap_collect_abandon (line 184) | void _mi_heap_collect_abandon(mi_heap_t* heap) {
  function mi_heap_collect (line 188) | void mi_heap_collect(mi_heap_t* heap, bool force) mi_attr_noexcept {
  function mi_collect (line 192) | void mi_collect(bool force) mi_attr_noexcept {
  function mi_heap_t (line 201) | mi_heap_t* mi_heap_get_default(void) {
  function mi_heap_is_default (line 206) | static bool mi_heap_is_default(const mi_heap_t* heap) {
  function mi_heap_t (line 211) | mi_heap_t* mi_heap_get_backing(void) {
  function _mi_heap_init (line 220) | void _mi_heap_init(mi_heap_t* heap, mi_tld_t* tld, mi_arena_id_t arena_i...
  function mi_decl_nodiscard (line 242) | mi_decl_nodiscard mi_heap_t* mi_heap_new_ex(int heap_tag, bool allow_des...
  function mi_decl_nodiscard (line 251) | mi_decl_nodiscard mi_heap_t* mi_heap_new_in_arena(mi_arena_id_t arena_id) {
  function mi_decl_nodiscard (line 255) | mi_decl_nodiscard mi_heap_t* mi_heap_new(void) {
  function _mi_heap_memid_is_suitable (line 260) | bool _mi_heap_memid_is_suitable(mi_heap_t* heap, mi_memid_t memid) {
  function _mi_heap_random_next (line 264) | uintptr_t _mi_heap_random_next(mi_heap_t* heap) {
  function mi_heap_reset_pages (line 269) | static void mi_heap_reset_pages(mi_heap_t* heap) {
  function mi_heap_free (line 280) | static void mi_heap_free(mi_heap_t* heap) {
  function mi_heap_t (line 311) | mi_heap_t* _mi_heap_by_tag(mi_heap_t* heap, uint8_t tag) {
  function _mi_heap_page_destroy (line 327) | static bool _mi_heap_page_destroy(mi_heap_t* heap, mi_page_queue_t* pq, ...
  function _mi_heap_destroy_pages (line 372) | void _mi_heap_destroy_pages(mi_heap_t* heap) {
  function mi_heap_track_block_free (line 378) | static bool mi_cdecl mi_heap_track_block_free(const mi_heap_t* heap, con...
  function mi_heap_destroy (line 385) | void mi_heap_destroy(mi_heap_t* heap) {
  function _mi_heap_unsafe_destroy_all (line 414) | void _mi_heap_unsafe_destroy_all(mi_heap_t* heap) {
  function mi_heap_absorb (line 435) | static void mi_heap_absorb(mi_heap_t* heap, mi_heap_t* from) {
  function mi_heaps_are_compatible (line 469) | static bool mi_heaps_are_compatible(mi_heap_t* heap1, mi_heap_t* heap2) {
  function mi_heap_delete (line 475) | void mi_heap_delete(mi_heap_t* heap)
  function mi_heap_t (line 495) | mi_heap_t* mi_heap_set_default(mi_heap_t* heap) {
  function mi_heap_t (line 513) | static mi_heap_t* mi_heap_of_block(const void* p) {
  function mi_heap_contains_block (line 522) | bool mi_heap_contains_block(mi_heap_t* heap, const void* p) {
  function mi_heap_page_check_owned (line 529) | static bool mi_heap_page_check_owned(mi_heap_t* heap, mi_page_queue_t* p...
  function mi_heap_check_owned (line 539) | bool mi_heap_check_owned(mi_heap_t* heap, const void* p) {
  function mi_check_owned (line 548) | bool mi_check_owned(const void* p) {
  function _mi_heap_area_init (line 558) | void _mi_heap_area_init(mi_heap_area_t* area, mi_page_t* page) {
  function mi_get_fast_divisor (line 571) | static void mi_get_fast_divisor(size_t divisor, uint64_t* magic, size_t*...
  function mi_fast_divide (line 577) | static size_t mi_fast_divide(size_t n, uint64_t magic, size_t shift) {
  function _mi_heap_area_visit_blocks (line 583) | bool _mi_heap_area_visit_blocks(const mi_heap_area_t* area, mi_page_t* p...
  type mi_heap_area_ex_t (line 690) | typedef struct mi_heap_area_ex_s {
  function mi_heap_visit_areas_page (line 697) | static bool mi_heap_visit_areas_page(mi_heap_t* heap, mi_page_queue_t* p...
  function mi_heap_visit_areas (line 708) | static bool mi_heap_visit_areas(const mi_heap_t* heap, mi_heap_area_visi...
  type mi_visit_blocks_args_t (line 714) | typedef struct mi_visit_blocks_args_s {
  function mi_heap_area_visitor (line 720) | static bool mi_heap_area_visitor(const mi_heap_t* heap, const mi_heap_ar...
  function mi_heap_visit_blocks (line 732) | bool mi_heap_visit_blocks(const mi_heap_t* heap, bool visit_blocks, mi_b...

FILE: third-party/mimalloc/src/init.c
  function mi_threadid_t (line 144) | mi_threadid_t _mi_thread_id(void) mi_attr_noexcept {
  function mi_decl_export (line 186) | mi_decl_export void mi_heap_guarded_set_sample_rate(mi_heap_t* heap, siz...
  function mi_decl_export (line 198) | mi_decl_export void mi_heap_guarded_set_size_bound(mi_heap_t* heap, size...
  function _mi_heap_guarded_init (line 203) | void _mi_heap_guarded_init(mi_heap_t* heap) {
  function mi_decl_export (line 212) | mi_decl_export void mi_heap_guarded_set_sample_rate(mi_heap_t* heap, siz...
  function mi_decl_export (line 216) | mi_decl_export void mi_heap_guarded_set_size_bound(mi_heap_t* heap, size...
  function _mi_heap_guarded_init (line 219) | void _mi_heap_guarded_init(mi_heap_t* heap) {
  function mi_heap_main_init (line 225) | static void mi_heap_main_init(void) {
  function mi_heap_t (line 243) | mi_heap_t* _mi_heap_main_get(void) {
  function mi_subproc_id_t (line 253) | mi_subproc_id_t mi_subproc_main(void) {
  function mi_subproc_id_t (line 257) | mi_subproc_id_t mi_subproc_new(void) {
  function mi_subproc_t (line 268) | mi_subproc_t* _mi_subproc_from_id(mi_subproc_id_t subproc_id) {
  function mi_subproc_delete (line 272) | void mi_subproc_delete(mi_subproc_id_t subproc_id) {
  function mi_subproc_add_current_thread (line 290) | void mi_subproc_add_current_thread(mi_subproc_id_t subproc_id) {
  type mi_thread_data_t (line 305) | typedef struct mi_thread_data_s {
  function mi_thread_data_t (line 320) | static mi_thread_data_t* mi_thread_data_zalloc(void) {
  function mi_thread_data_free (line 359) | static void mi_thread_data_free( mi_thread_data_t* tdfree ) {
  function _mi_thread_data_collect (line 374) | void _mi_thread_data_collect(void) {
  function _mi_thread_heap_init (line 388) | static bool _mi_thread_heap_init(void) {
  function _mi_tld_init (line 412) | void _mi_tld_init(mi_tld_t* tld, mi_heap_t* bheap) {
  function _mi_thread_heap_done (line 421) | static bool _mi_thread_heap_done(mi_heap_t* heap) {
  function mi_process_setup_auto_thread_done (line 490) | static void mi_process_setup_auto_thread_done(void) {
  function _mi_is_main_thread (line 499) | bool _mi_is_main_thread(void) {
  function _mi_current_thread_count (line 505) | size_t  _mi_current_thread_count(void) {
  function mi_thread_init (line 510) | void mi_thread_init(void) mi_attr_noexcept
  function mi_thread_done (line 525) | void mi_thread_done(void) mi_attr_noexcept {
  function _mi_thread_done (line 529) | void _mi_thread_done(mi_heap_t* heap)
  function _mi_heap_set_default_direct (line 553) | void _mi_heap_set_default_direct(mi_heap_t* heap)  {
  function mi_thread_set_in_threadpool (line 570) | void mi_thread_set_in_threadpool(void) mi_attr_noexcept {
  function _mi_preloading (line 580) | _mi_preloading(void) {
  function mi_decl_nodiscard (line 585) | mi_decl_nodiscard bool mi_is_redirected(void) mi_attr_noexcept {
  function _mi_process_load (line 590) | void _mi_process_load(void) {
  function mi_detect_cpu_features (line 619) | static void mi_detect_cpu_features(void) {
  function mi_detect_cpu_features (line 628) | static void mi_detect_cpu_features(void) {
  function mi_process_init (line 634) | void mi_process_init(void) mi_attr_noexcept {
  function _mi_process_done (line 678) | void mi_cdecl _mi_process_done(void) {

FILE: third-party/mimalloc/src/libc.c
  function _mi_toupper (line 19) | char _mi_toupper(char c) {
  function _mi_strnicmp (line 24) | int _mi_strnicmp(const char* s, const char* t, size_t n) {
  function _mi_strlcpy (line 32) | void _mi_strlcpy(char* dest, const char* src, size_t dest_size) {
  function _mi_strlcat (line 43) | void _mi_strlcat(char* dest, const char* src, size_t dest_size) {
  function _mi_strlen (line 54) | size_t _mi_strlen(const char* s) {
  function _mi_strnlen (line 61) | size_t _mi_strnlen(const char* s, size_t max_len) {
  function _mi_getenv (line 69) | bool _mi_getenv(const char* name, char* result, size_t result_size) {
  function _mi_getenv (line 76) | bool _mi_getenv(const char* name, char* result, size_t result_size) {
  function mi_outc (line 95) | static void mi_outc(char c, char** out, char* end) {
  function mi_outs (line 102) | static void mi_outs(const char* s, char** out, char* end) {
  function mi_out_fill (line 111) | static void mi_out_fill(char fill, size_t len, char** out, char* end) {
  function mi_out_alignright (line 119) | static void mi_out_alignright(char fill, char* start, size_t len, size_t...
  function mi_out_num (line 133) | static void mi_out_num(uintmax_t x, size_t base, char prefix, char** out...
  function _mi_vsnprintf (line 163) | int _mi_vsnprintf(char* buf, size_t bufsize, const char* fmt, va_list ar...
  function _mi_snprintf (line 271) | int _mi_snprintf(char* buf, size_t buflen, const char* fmt, ...) {

FILE: third-party/mimalloc/src/options.c
  function mi_version (line 22) | int mi_version(void) mi_attr_noexcept {
  type mi_init_t (line 33) | typedef enum mi_init_e {
  type mi_option_desc_t (line 39) | typedef struct mi_option_desc_s {
  function mi_option_has_size_in_kib (line 170) | static bool mi_option_has_size_in_kib(mi_option_t option) {
  function _mi_options_init (line 174) | void _mi_options_init(void) {
  function mi_options_print (line 197) | void mi_options_print(void) mi_attr_noexcept
  function _mi_option_get_fast (line 237) | long _mi_option_get_fast(mi_option_t option) {
  function mi_option_get (line 246) | mi_decl_nodiscard long mi_option_get(mi_option_t option) {
  function mi_option_get_clamp (line 257) | mi_decl_nodiscard long mi_option_get_clamp(mi_option_t option, long min,...
  function mi_decl_nodiscard (line 262) | mi_decl_nodiscard size_t mi_option_get_size(mi_option_t option) {
  function mi_option_set (line 271) | void mi_option_set(mi_option_t option, long value) {
  function mi_option_set_default (line 287) | void mi_option_set_default(mi_option_t option, long value) {
  function mi_decl_nodiscard (line 296) | mi_decl_nodiscard bool mi_option_is_enabled(mi_option_t option) {
  function mi_option_set_enabled (line 300) | void mi_option_set_enabled(mi_option_t option, bool enable) {
  function mi_option_set_enabled_default (line 304) | void mi_option_set_enabled_default(mi_option_t option, bool enable) {
  function mi_option_enable (line 308) | void mi_option_enable(mi_option_t option) {
  function mi_option_disable (line 312) | void mi_option_disable(mi_option_t option) {
  function mi_out_stderr (line 316) | static void mi_cdecl mi_out_stderr(const char* msg, void* arg) {
  function mi_out_buf (line 333) | static void mi_cdecl mi_out_buf(const char* msg, void* arg) {
  function mi_out_buf_flush (line 349) | static void mi_out_buf_flush(mi_output_fun* out, bool no_more_buf, void*...
  function mi_out_buf_stderr (line 365) | static void mi_cdecl mi_out_buf_stderr(const char* msg, void* arg) {
  function mi_output_fun (line 381) | static mi_output_fun* mi_out_get_default(void** parg) {
  function mi_register_output (line 387) | void mi_register_output(mi_output_fun* out, void* arg) mi_attr_noexcept {
  function mi_add_stderr_output (line 394) | static void mi_add_stderr_output(void) {
  function mi_decl_noinline (line 417) | static mi_decl_noinline bool mi_recurse_enter_prim(void) {
  function mi_decl_noinline (line 423) | static mi_decl_noinline void mi_recurse_exit_prim(void) {
  function mi_recurse_enter (line 427) | static bool mi_recurse_enter(void) {
  function mi_recurse_exit (line 434) | static void mi_recurse_exit(void) {
  function _mi_fputs (line 441) | void _mi_fputs(mi_output_fun* out, void* arg, const char* prefix, const ...
  function mi_vfprintf (line 457) | static void mi_vfprintf( mi_output_fun* out, void* arg, const char* pref...
  function _mi_fprintf (line 466) | void _mi_fprintf( mi_output_fun* out, void* arg, const char* fmt, ... ) {
  function mi_vfprintf_thread (line 473) | static void mi_vfprintf_thread(mi_output_fun* out, void* arg, const char...
  function _mi_message (line 484) | void _mi_message(const char* fmt, ...) {
  function _mi_trace_message (line 491) | void _mi_trace_message(const char* fmt, ...) {
  function _mi_verbose_message (line 499) | void _mi_verbose_message(const char* fmt, ...) {
  function mi_show_error_message (line 507) | static void mi_show_error_message(const char* fmt, va_list args) {
  function _mi_warning_message (line 515) | void _mi_warning_message(const char* fmt, ...) {
  function _mi_assert_fail (line 528) | void _mi_assert_fail(const char* assertion, const char* fname, unsigned ...
  function mi_error_default (line 541) | static void mi_error_default(int err) {
  function mi_register_error (line 563) | void mi_register_error(mi_error_fun* fun, void* arg) {
  function _mi_error_message (line 568) | void _mi_error_message(int err, const char* fmt, ...) {
  function mi_option_init (line 592) | static void mi_option_init(mi_option_desc_t* desc) {

FILE: third-party/mimalloc/src/os.c
  function _mi_os_has_overcommit (line 46) | bool _mi_os_has_overcommit(void) {
  function _mi_os_has_virtual_reserve (line 50) | bool _mi_os_has_virtual_reserve(void) {
  function _mi_os_page_size (line 56) | size_t _mi_os_page_size(void) {
  function _mi_os_large_page_size (line 61) | size_t _mi_os_large_page_size(void) {
  function _mi_os_use_large_page (line 65) | bool _mi_os_use_large_page(size_t size, size_t alignment) {
  function _mi_os_good_alloc_size (line 72) | size_t _mi_os_good_alloc_size(size_t size) {
  function _mi_os_init (line 83) | void _mi_os_init(void) {
  function mi_os_prim_free (line 153) | static void mi_os_prim_free(void* addr, size_t size, size_t commit_size) {
  function _mi_os_free_ex (line 166) | void _mi_os_free_ex(void* addr, size_t size, bool still_committed, mi_me...
  function _mi_os_free (line 199) | void  _mi_os_free(void* p, size_t size, mi_memid_t memid) {
  function _mi_os_commit_ex (line 416) | bool _mi_os_commit_ex(void* addr, size_t size, bool* is_zero, size_t sta...
  function _mi_os_commit (line 445) | bool _mi_os_commit(void* addr, size_t size, bool* is_zero) {
  function mi_os_decommit_ex (line 449) | static bool mi_os_decommit_ex(void* addr, size_t size, bool* needs_recom...
  function _mi_os_decommit (line 468) | bool _mi_os_decommit(void* addr, size_t size) {
  function _mi_os_reset (line 478) | bool _mi_os_reset(void* addr, size_t size) {
  function _mi_os_purge_ex (line 500) | bool _mi_os_purge_ex(void* p, size_t size, bool allow_reset, size_t stat...
  function _mi_os_purge (line 523) | bool _mi_os_purge(void* p, size_t size) {
  function mi_os_protectx (line 528) | static  bool mi_os_protectx(void* addr, size_t size, bool protect) {
  function _mi_os_protect (line 545) | bool _mi_os_protect(void* addr, size_t size) {
  function _mi_os_unprotect (line 549) | bool _mi_os_unprotect(void* addr, size_t size) {
  function mi_os_free_huge_os_pages (line 673) | static void mi_os_free_huge_os_pages(void* p, size_t size) {
  function _mi_os_numa_node_count_get (line 689) | size_t _mi_os_numa_node_count_get(void) {
  function _mi_os_numa_node_get (line 706) | int _mi_os_numa_node_get(void) {

FILE: third-party/mimalloc/src/page-queue.c
  function mi_page_queue_is_huge (line 40) | static inline bool mi_page_queue_is_huge(const mi_page_queue_t* pq) {
  function mi_page_queue_is_full (line 44) | static inline bool mi_page_queue_is_full(const mi_page_queue_t* pq) {
  function mi_page_queue_is_special (line 48) | static inline bool mi_page_queue_is_special(const mi_page_queue_t* pq) {
  function mi_bin (line 60) | static inline size_t mi_bin(size_t size) {
  function _mi_bin (line 100) | size_t _mi_bin(size_t size) {
  function _mi_bin_size (line 104) | size_t _mi_bin_size(size_t bin) {
  function mi_good_size (line 109) | size_t mi_good_size(size_t size) mi_attr_noexcept {
  function mi_page_queue_contains (line 119) | static bool mi_page_queue_contains(mi_page_queue_t* queue, const mi_page...
  function mi_heap_contains_queue (line 134) | static bool mi_heap_contains_queue(const mi_heap_t* heap, const mi_page_...
  function mi_page_is_large_or_huge (line 139) | static inline bool mi_page_is_large_or_huge(const mi_page_t* page) {
  function mi_page_bin (line 143) | static size_t mi_page_bin(const mi_page_t* page) {
  function mi_page_queue_t (line 149) | static mi_page_queue_t* mi_heap_page_queue_of(mi_heap_t* heap, const mi_...
  function mi_page_queue_t (line 159) | static mi_page_queue_t* mi_page_queue_of(const mi_page_t* page) {
  function mi_heap_queue_first_update (line 171) | static inline void mi_heap_queue_first_update(mi_heap_t* heap, const mi_...
  function mi_page_queue_remove (line 214) | static void mi_page_queue_remove(mi_page_queue_t* queue, mi_page_t* page) {
  function mi_page_queue_push (line 239) | static void mi_page_queue_push(mi_heap_t* heap, mi_page_queue_t* queue, ...
  function mi_page_queue_move_to_front (line 267) | static void mi_page_queue_move_to_front(mi_heap_t* heap, mi_page_queue_t...
  function mi_page_queue_enqueue_from_ex (line 276) | static void mi_page_queue_enqueue_from_ex(mi_page_queue_t* to, mi_page_q...
  function mi_page_queue_enqueue_from (line 345) | static void mi_page_queue_enqueue_from(mi_page_queue_t* to, mi_page_queu...
  function mi_page_queue_enqueue_from_full (line 349) | static void mi_page_queue_enqueue_from_full(mi_page_queue_t* to, mi_page...
  function _mi_page_queue_append (line 355) | size_t _mi_page_queue_append(mi_heap_t* heap, mi_page_queue_t* pq, mi_pa...

FILE: third-party/mimalloc/src/page.c
  function mi_block_t (line 32) | static inline mi_block_t* mi_page_block_at(const mi_page_t* page, void* ...
  function mi_page_list_count (line 43) | static size_t mi_page_list_count(mi_page_t* page, mi_block_t* head) {
  function mi_page_list_is_valid (line 60) | static bool mi_page_list_is_valid(mi_page_t* page, mi_block_t* p) {
  function mi_page_is_valid_init (line 80) | static bool mi_page_is_valid_init(mi_page_t* page) {
  function _mi_page_is_valid (line 117) | bool _mi_page_is_valid(mi_page_t* page) {
  function _mi_page_use_delayed_free (line 140) | void _mi_page_use_delayed_free(mi_page_t* page, mi_delayed_t delay, bool...
  function _mi_page_try_use_delayed_free (line 146) | bool _mi_page_try_use_delayed_free(mi_page_t* page, mi_delayed_t delay, ...
  function _mi_page_thread_free_collect (line 181) | static void _mi_page_thread_free_collect(mi_page_t* page)
  function _mi_page_free_collect (line 217) | void _mi_page_free_collect(mi_page_t* page, bool force) {
  function _mi_page_reclaim (line 257) | void _mi_page_reclaim(mi_heap_t* heap, mi_page_t* page) {
  function mi_page_t (line 273) | static mi_page_t* mi_page_fresh_alloc(mi_heap_t* heap, mi_page_queue_t* ...
  function mi_page_t (line 301) | static mi_page_t* mi_page_fresh(mi_heap_t* heap, mi_page_queue_t* pq) {
  function _mi_heap_delayed_free_all (line 314) | void _mi_heap_delayed_free_all(mi_heap_t* heap) {
  function _mi_heap_delayed_free_partial (line 321) | bool _mi_heap_delayed_free_partial(mi_heap_t* heap) {
  function _mi_page_unfull (line 351) | void _mi_page_unfull(mi_page_t* page) {
  function mi_page_to_full (line 365) | static void mi_page_to_full(mi_page_t* page, mi_page_queue_t* pq) {
  function _mi_page_abandon (line 380) | void _mi_page_abandon(mi_page_t* page, mi_page_queue_t* pq) {
  function _mi_page_force_abandon (line 409) | void _mi_page_force_abandon(mi_page_t* page) {
  function _mi_page_free (line 432) | void _mi_page_free(mi_page_t* page, mi_page_queue_t* pq, bool force) {
  function _mi_page_retire (line 463) | void _mi_page_retire(mi_page_t* page) mi_attr_noexcept {
  function _mi_heap_collect_retired (line 499) | void _mi_heap_collect_retired(mi_heap_t* heap, bool force) {
  function mi_page_free_list_extend_secure (line 537) | static void mi_page_free_list_extend_secure(mi_heap_t* const heap, mi_pa...
  function mi_decl_noinline (line 594) | static mi_decl_noinline void mi_page_free_list_extend( mi_page_t* const ...
  function mi_page_extend_free (line 636) | static void mi_page_extend_free(mi_heap_t* heap, mi_page_t* page, mi_tld...
  function mi_page_init (line 680) | static void mi_page_init(mi_heap_t* heap, mi_page_t* page, size_t block_...
  function mi_page_is_expandable (line 744) | static bool mi_page_is_expandable(const mi_page_t* page) {
  function mi_page_t (line 752) | static mi_page_t* mi_page_queue_find_free_ex(mi_heap_t* heap, mi_page_qu...
  function mi_page_t (line 852) | static inline mi_page_t* mi_find_free_page(mi_heap_t* heap, size_t size) {
  function _mi_deferred_free (line 889) | void _mi_deferred_free(mi_heap_t* heap, bool force) {
  function mi_register_deferred_free (line 898) | void mi_register_deferred_free(mi_deferred_free_fun* fn, void* arg) mi_a...
  function mi_page_t (line 912) | static mi_page_t* mi_large_huge_page_alloc(mi_heap_t* heap, size_t size,...
  function mi_page_t (line 956) | static mi_page_t* mi_find_page(mi_heap_t* heap, size_t size, size_t huge...

FILE: third-party/mimalloc/src/prim/emscripten/prim.c
  function _mi_prim_mem_init (line 50) | void _mi_prim_mem_init( mi_os_mem_config_t* config) {
  function _mi_prim_free (line 60) | int _mi_prim_free(void* addr, size_t size) {
  function _mi_prim_alloc (line 74) | int _mi_prim_alloc(void* hint_addr, size_t size, size_t try_alignment, b...
  function _mi_prim_commit (line 99) | int _mi_prim_commit(void* addr, size_t size, bool* is_zero) {
  function _mi_prim_decommit (line 106) | int _mi_prim_decommit(void* addr, size_t size, bool* needs_recommit) {
  function _mi_prim_reset (line 112) | int _mi_prim_reset(void* addr, size_t size) {
  function _mi_prim_protect (line 117) | int _mi_prim_protect(void* addr, size_t size, bool protect) {
  function _mi_prim_alloc_huge_os_pages (line 127) | int _mi_prim_alloc_huge_os_pages(void* hint_addr, size_t size, int numa_...
  function _mi_prim_numa_node (line 134) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 138) | size_t _mi_prim_numa_node_count(void) {
  function mi_msecs_t (line 149) | mi_msecs_t _mi_prim_clock_now(void) {
  function _mi_prim_process_info (line 158) | void _mi_prim_process_info(mi_process_info_t* pinfo)
  function _mi_prim_out_stderr (line 171) | void _mi_prim_out_stderr( const char* msg) {
  function _mi_prim_getenv (line 180) | bool _mi_prim_getenv(const char* name, char* result, size_t result_size) {
  function _mi_prim_random_buf (line 193) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function mi_pthread_done (line 209) | static void mi_pthread_done(void* value) {
  function _mi_prim_thread_init_auto_done (line 215) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 220) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 224) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {
  function _mi_prim_thread_init_auto_done (line 232) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 236) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 240) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {

FILE: third-party/mimalloc/src/prim/osx/alloc-override-zone.c
  function zone_size (line 44) | static size_t zone_size(malloc_zone_t* zone, const void* p) {
  function zone_free (line 65) | static void zone_free(malloc_zone_t* zone, void* p) {
  function zone_destroy (line 80) | static void zone_destroy(malloc_zone_t* zone) {
  function zone_batch_malloc (line 85) | static unsigned zone_batch_malloc(malloc_zone_t* zone, size_t size, void...
  function zone_batch_free (line 94) | static void zone_batch_free(malloc_zone_t* zone, void** ps, unsigned cou...
  function zone_pressure_relief (line 101) | static size_t zone_pressure_relief(malloc_zone_t* zone, size_t size) {
  function zone_free_definite_size (line 107) | static void zone_free_definite_size(malloc_zone_t* zone, void* p, size_t...
  function boolean_t (line 112) | static boolean_t zone_claimed_address(malloc_zone_t* zone, void* p) {
  function kern_return_t (line 122) | static kern_return_t intro_enumerator(task_t task, void* p,
  function intro_good_size (line 133) | static size_t intro_good_size(malloc_zone_t* zone, size_t size) {
  function boolean_t (line 138) | static boolean_t intro_check(malloc_zone_t* zone) {
  function intro_print (line 143) | static void intro_print(malloc_zone_t* zone, boolean_t verbose) {
  function intro_log (line 148) | static void intro_log(malloc_zone_t* zone, void* p) {
  function intro_force_lock (line 153) | static void intro_force_lock(malloc_zone_t* zone) {
  function intro_force_unlock (line 158) | static void intro_force_unlock(malloc_zone_t* zone) {
  function intro_statistics (line 163) | static void intro_statistics(malloc_zone_t* zone, malloc_statistics_t* s...
  function boolean_t (line 172) | static boolean_t intro_zone_locked(malloc_zone_t* zone) {
  function malloc_zone_t (line 256) | static inline malloc_zone_t* mi_get_default_zone(void)
  function malloc_zone_t (line 272) | static malloc_zone_t* mi_malloc_create_zone(vm_size_t size, unsigned fla...
  function malloc_zone_t (line 277) | static malloc_zone_t* mi_malloc_default_zone (void) {
  function malloc_zone_t (line 281) | static malloc_zone_t* mi_malloc_default_purgeable_zone(void) {
  function mi_malloc_destroy_zone (line 285) | static void mi_malloc_destroy_zone(malloc_zone_t* zone) {
  function kern_return_t (line 290) | static kern_return_t mi_malloc_get_all_zones (task_t task, memory_reader...
  function mi_malloc_set_zone_name (line 301) | static void mi_malloc_set_zone_name(malloc_zone_t* zone, const char* nam...
  function mi_malloc_jumpstart (line 305) | static int mi_malloc_jumpstart(uintptr_t cookie) {
  function mi__malloc_fork_prepare (line 310) | static void mi__malloc_fork_prepare(void) {
  function mi__malloc_fork_parent (line 313) | static void mi__malloc_fork_parent(void) {
  function mi__malloc_fork_child (line 316) | static void mi__malloc_fork_child(void) {
  function mi_malloc_printf (line 320) | static void mi_malloc_printf(const char* fmt, ...) {
  function zone_check (line 324) | static bool zone_check(malloc_zone_t* zone) {
  function malloc_zone_t (line 329) | static malloc_zone_t* zone_from_ptr(const void* p) {
  function zone_log (line 334) | static void zone_log(malloc_zone_t* zone, void* p) {
  function zone_print (line 338) | static void zone_print(malloc_zone_t* zone, bool b) {
  function zone_print_ptr_info (line 342) | static void zone_print_ptr_info(void* p) {
  function zone_register (line 346) | static void zone_register(malloc_zone_t* zone) {
  function zone_unregister (line 350) | static void zone_unregister(malloc_zone_t* zone) {
  type mi_interpose_s (line 356) | struct mi_interpose_s {
  type mi_interpose_s (line 363) | struct mi_interpose_s
  function malloc_zone_t (line 405) | static inline malloc_zone_t* mi_get_default_zone(void)
  function _mi_macos_override_malloc (line 421) | __attribute__((constructor(101))) // highest priority

FILE: third-party/mimalloc/src/prim/prim.c
  function mi_process_attach (line 41) | mi_process_attach(void) {
  function mi_process_detach (line 44) | mi_process_detach(void) {
  function mi_init_done_t (line 50) | struct mi_init_done_t {
  function _mi_is_redirected (line 66) | bool _mi_is_redirected(void) {
  function _mi_allocator_init (line 69) | bool _mi_allocator_init(const char** message) {
  function _mi_allocator_done (line 73) | void _mi_allocator_done(void) {

FILE: third-party/mimalloc/src/prim/unix/prim.c
  function mi_prim_open (line 82) | static inline int mi_prim_open(const char* fpath, int open_flags) {
  function mi_prim_read (line 85) | static inline ssize_t mi_prim_read(int fd, void* buf, size_t bufsize) {
  function mi_prim_close (line 88) | static inline int mi_prim_close(int fd) {
  function mi_prim_access (line 91) | static inline int mi_prim_access(const char *fpath, int mode) {
  function mi_prim_open (line 97) | static inline int mi_prim_open(const char* fpath, int open_flags) {
  function mi_prim_read (line 100) | static inline ssize_t mi_prim_read(int fd, void* buf, size_t bufsize) {
  function mi_prim_close (line 103) | static inline int mi_prim_close(int fd) {
  function mi_prim_access (line 106) | static inline int mi_prim_access(const char *fpath, int mode) {
  function unix_detect_overcommit (line 118) | static bool unix_detect_overcommit(void) {
  function _mi_prim_mem_init (line 144) | void _mi_prim_mem_init( mi_os_mem_config_t* config )
  function _mi_prim_free (line 187) | int _mi_prim_free(void* addr, size_t size ) {
  function unix_madvise (line 197) | static int unix_madvise(void* addr, size_t size, int advice) {
  function unix_mmap_fd (line 257) | static int unix_mmap_fd(void) {
  type memcntl_mha (line 359) | struct memcntl_mha
  function _mi_prim_alloc (line 373) | int _mi_prim_alloc(void* hint_addr, size_t size, size_t try_alignment, b...
  function unix_mprotect_hint (line 389) | static void unix_mprotect_hint(int err) {
  function _mi_prim_commit (line 401) | int _mi_prim_commit(void* start, size_t size, bool* is_zero) {
  function _mi_prim_decommit (line 416) | int _mi_prim_decommit(void* start, size_t size, bool* needs_recommit) {
  function _mi_prim_reset (line 436) | int _mi_prim_reset(void* start, size_t size) {
  function _mi_prim_protect (line 457) | int _mi_prim_protect(void* start, size_t size, bool protect) {
  function mi_prim_mbind (line 477) | static long mi_prim_mbind(void* start, unsigned long len, unsigned long ...
  function mi_prim_mbind (line 481) | static long mi_prim_mbind(void* start, unsigned long len, unsigned long ...
  function _mi_prim_alloc_huge_os_pages (line 487) | int _mi_prim_alloc_huge_os_pages(void* hint_addr, size_t size, int numa_...
  function _mi_prim_alloc_huge_os_pages (line 507) | int _mi_prim_alloc_huge_os_pages(void* hint_addr, size_t size, int numa_...
  function _mi_prim_numa_node (line 522) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 534) | size_t _mi_prim_numa_node_count(void) {
  function _mi_prim_numa_node (line 547) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 558) | size_t _mi_prim_numa_node_count(void) {
  function _mi_prim_numa_node (line 567) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 572) | size_t _mi_prim_numa_node_count(void) {
  function _mi_prim_numa_node (line 582) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 586) | size_t _mi_prim_numa_node_count(void) {
  function mi_msecs_t (line 600) | mi_msecs_t _mi_prim_clock_now(void) {
  function mi_msecs_t (line 613) | mi_msecs_t _mi_prim_clock_now(void) {
  function mi_msecs_t (line 645) | static mi_msecs_t timeval_secs(const struct timeval* tv) {
  function _mi_prim_process_info (line 649) | void _mi_prim_process_info(mi_process_info_t* pinfo)
  function _mi_prim_process_info (line 697) | void _mi_prim_process_info(mi_process_info_t* pinfo)
  function _mi_prim_out_stderr (line 710) | void _mi_prim_out_stderr( const char* msg ) {
  function _mi_prim_getenv (line 733) | bool _mi_prim_getenv(const char* name, char* result, size_t result_size) {
  function _mi_prim_getenv (line 752) | bool _mi_prim_getenv(const char* name, char* result, size_t result_size) {
  function _mi_prim_random_buf (line 781) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function _mi_prim_random_buf (line 792) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function _mi_prim_random_buf (line 803) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function _mi_prim_random_buf (line 842) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function mi_pthread_done (line 859) | static void mi_pthread_done(void* value) {
  function _mi_prim_thread_init_auto_done (line 865) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 870) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 876) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {
  function _mi_prim_thread_init_auto_done (line 884) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 888) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 892) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {

FILE: third-party/mimalloc/src/prim/wasi/prim.c
  function _mi_prim_mem_init (line 21) | void _mi_prim_mem_init( mi_os_mem_config_t* config ) {
  function _mi_prim_free (line 33) | int _mi_prim_free(void* addr, size_t size ) {
  function _mi_prim_alloc (line 122) | int _mi_prim_alloc(void* hint_addr, size_t size, size_t try_alignment, b...
  function _mi_prim_commit (line 135) | int _mi_prim_commit(void* addr, size_t size, bool* is_zero) {
  function _mi_prim_decommit (line 141) | int _mi_prim_decommit(void* addr, size_t size, bool* needs_recommit) {
  function _mi_prim_reset (line 147) | int _mi_prim_reset(void* addr, size_t size) {
  function _mi_prim_protect (line 152) | int _mi_prim_protect(void* addr, size_t size, bool protect) {
  function _mi_prim_alloc_huge_os_pages (line 162) | int _mi_prim_alloc_huge_os_pages(void* hint_addr, size_t size, int numa_...
  function _mi_prim_numa_node (line 169) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 173) | size_t _mi_prim_numa_node_count(void) {
  function mi_msecs_t (line 186) | mi_msecs_t _mi_prim_clock_now(void) {
  function mi_msecs_t (line 199) | mi_msecs_t _mi_prim_clock_now(void) {
  function _mi_prim_process_info (line 216) | void _mi_prim_process_info(mi_process_info_t* pinfo)
  function _mi_prim_out_stderr (line 227) | void _mi_prim_out_stderr( const char* msg ) {
  function _mi_prim_getenv (line 236) | bool _mi_prim_getenv(const char* name, char* result, size_t result_size) {
  function _mi_prim_random_buf (line 260) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function _mi_prim_thread_init_auto_done (line 269) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 273) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 277) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {

FILE: third-party/mimalloc/src/prim/windows/etw.h
  type MCGEN_TRACE_CONTEXT (line 243) | typedef struct _MCGEN_TRACE_CONTEXT
  function FORCEINLINE (line 268) | FORCEINLINE
  function FORCEINLINE (line 308) | FORCEINLINE
  function DECLSPEC_NOINLINE (line 323) | DECLSPEC_NOINLINE __inline
  type _mcgen_PASTE2 (line 457) | struct _mcgen_PASTE2
  type _mcgen_PASTE2 (line 460) | struct _mcgen_PASTE2
  type MCGEN_EVENTREGISTER_must_not_be_a_functionLike_macro_MCGEN_EVENTREGISTER (line 464) | typedef void MCGEN_EVENTREGISTER_must_not_be_a_functionLike_macro_MCGEN_...
  type _mcgen_PASTE2 (line 470) | struct _mcgen_PASTE2
  type _mcgen_PASTE2 (line 473) | struct _mcgen_PASTE2
  type MCGEN_EVENTUNREGISTER_must_not_be_a_functionLike_macro_MCGEN_EVENTUNREGISTER (line 477) | typedef void MCGEN_EVENTUNREGISTER_must_not_be_a_functionLike_macro_MCGE...
  type _mcgen_PASTE2 (line 483) | struct _mcgen_PASTE2
  type _mcgen_PASTE2 (line 486) | struct _mcgen_PASTE2
  type MCGEN_EVENTSETINFORMATION_must_not_be_a_functionLike_macro_MCGEN_EVENTSETINFORMATION (line 490) | typedef void MCGEN_EVENTSETINFORMATION_must_not_be_a_functionLike_macro_...
  type _mcgen_PASTE2 (line 496) | struct _mcgen_PASTE2
  type _mcgen_PASTE2 (line 499) | struct _mcgen_PASTE2
  type MCGEN_EVENTWRITETRANSFER_must_not_be_a_functionLike_macro_MCGEN_EVENTWRITETRANSFER (line 503) | typedef void MCGEN_EVENTWRITETRANSFER_must_not_be_a_functionLike_macro_M...
  function DECLSPEC_NOINLINE (line 513) | DECLSPEC_NOINLINE __inline
  function DECLSPEC_NOINLINE (line 559) | DECLSPEC_NOINLINE __inline
  function DECLSPEC_NOINLINE (line 611) | DECLSPEC_NOINLINE __inline
  type McGenContext_microsoft_windows_mimalloc (line 766) | typedef struct tagMcGenContext_microsoft_windows_mimalloc {
  function ULONG (line 785) | __inline
  function McGenContext_microsoft_windows_mimalloc (line 807) | McGenContext_microsoft_windows_mimalloc*
  function ETW_INLINE (line 880) | ETW_INLINE

FILE: third-party/mimalloc/src/prim/windows/prim.c
  type MI_MEM_EXTENDED_PARAMETER_TYPE (line 24) | typedef enum MI_MEM_EXTENDED_PARAMETER_TYPE_E {
  type DECLSPEC_ALIGN (line 34) | struct DECLSPEC_ALIGN
  type MI_MEM_ADDRESS_REQUIREMENTS (line 39) | typedef struct MI_MEM_ADDRESS_REQUIREMENTS_S {
  type PVOID (line 48) | typedef PVOID    (__stdcall *PVirtualAlloc2)(HANDLE, PVOID, SIZE_T, ULON...
  type NTSTATUS (line 49) | typedef NTSTATUS (__stdcall *PNtAllocateVirtualMemoryEx)(HANDLE, PVOID*,...
  type MI_PROCESSOR_NUMBER (line 54) | typedef struct MI_PROCESSOR_NUMBER_S { WORD Group; BYTE Number; BYTE Res...
  type VOID (line 56) | typedef VOID (__stdcall *PGetCurrentProcessorNumberEx)(MI_PROCESSOR_NUMB...
  type BOOL (line 57) | typedef BOOL (__stdcall *PGetNumaProcessorNodeEx)(MI_PROCESSOR_NUMBER* P...
  type BOOL (line 58) | typedef BOOL (__stdcall* PGetNumaNodeProcessorMaskEx)(USHORT Node, PGROU...
  type BOOL (line 59) | typedef BOOL (__stdcall *PGetNumaProcessorNode)(UCHAR Processor, PUCHAR ...
  type BOOL (line 66) | typedef BOOL (__stdcall *PGetPhysicallyInstalledSystemMemory)( PULONGLON...
  function win_enable_large_os_pages (line 72) | static bool win_enable_large_os_pages(size_t* large_page_size)
  function _mi_prim_mem_init (line 114) | void _mi_prim_mem_init( mi_os_mem_config_t* config )
  function _mi_prim_free (line 175) | int _mi_prim_free(void* addr, size_t size ) {
  function win_is_out_of_memory_error (line 229) | static bool win_is_out_of_memory_error(DWORD err) {
  function _mi_prim_alloc (line 302) | int _mi_prim_alloc(void* hint_addr, size_t size, size_t try_alignment, b...
  function _mi_prim_commit (line 321) | int _mi_prim_commit(void* addr, size_t size, bool* is_zero) {
  function _mi_prim_decommit (line 338) | int _mi_prim_decommit(void* addr, size_t size, bool* needs_recommit) {
  function _mi_prim_reset (line 344) | int _mi_prim_reset(void* addr, size_t size) {
  function _mi_prim_protect (line 355) | int _mi_prim_protect(void* addr, size_t size, bool protect) {
  function _mi_prim_alloc_huge_os_pages (line 407) | int _mi_prim_alloc_huge_os_pages(void* hint_addr, size_t size, int numa_...
  function _mi_prim_numa_node (line 418) | size_t _mi_prim_numa_node(void) {
  function _mi_prim_numa_node_count (line 438) | size_t _mi_prim_numa_node_count(void) {
  function mi_msecs_t (line 468) | static mi_msecs_t mi_to_msecs(LARGE_INTEGER t) {
  function mi_msecs_t (line 479) | mi_msecs_t _mi_prim_clock_now(void) {
  function mi_msecs_t (line 492) | static mi_msecs_t filetime_msecs(const FILETIME* ftime) {
  type PPROCESS_MEMORY_COUNTERS (line 500) | typedef BOOL (WINAPI *PGetProcessMemoryInfo)(HANDLE, PPROCESS_MEMORY_COU...
  function _mi_prim_process_info (line 503) | void _mi_prim_process_info(mi_process_info_t* pinfo)
  function _mi_prim_out_stderr (line 537) | void _mi_prim_out_stderr( const char* msg )
  function _mi_prim_getenv (line 577) | bool _mi_prim_getenv(const char* name, char* result, size_t result_size) {
  function _mi_prim_random_buf (line 598) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  type PUCHAR (line 608) | typedef LONG (NTAPI *PBCryptGenRandom)(HANDLE, PUCHAR, ULONG, ULONG);
  function _mi_prim_random_buf (line 611) | bool _mi_prim_random_buf(void* buf, size_t buf_len) {
  function mi_win_main (line 630) | static void NTAPI mi_win_main(PVOID module, DWORD reason, LPVOID reserve...
  function BOOL (line 654) | BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved) {
  function _mi_prim_thread_init_auto_done (line 660) | void _mi_prim_thread_init_auto_done(void) { }
  function _mi_prim_thread_done_auto_done (line 661) | void _mi_prim_thread_done_auto_done(void) { }
  function _mi_prim_thread_associate_default_heap (line 662) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {
  function mi_win_main_attach (line 669) | static void NTAPI mi_win_main_attach(PVOID module, DWORD reason, LPVOID ...
  function mi_win_main_detach (line 674) | static void NTAPI mi_win_main_detach(PVOID module, DWORD reason, LPVOID ...
  function _mi_prim_thread_init_auto_done (line 717) | void _mi_prim_thread_init_auto_done(void) { }
  function _mi_prim_thread_done_auto_done (line 718) | void _mi_prim_thread_done_auto_done(void) { }
  function _mi_prim_thread_associate_default_heap (line 719) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {
  function mi_process_attach (line 730) | static int mi_process_attach(void) {
  function mi_fls_done (line 758) | static void NTAPI mi_fls_done(PVOID value) {
  function _mi_prim_thread_init_auto_done (line 766) | void _mi_prim_thread_init_auto_done(void) {
  function _mi_prim_thread_done_auto_done (line 770) | void _mi_prim_thread_done_auto_done(void) {
  function _mi_prim_thread_associate_default_heap (line 776) | void _mi_prim_thread_associate_default_heap(mi_heap_t* heap) {
  function _mi_is_redirected (line 790) | bool _mi_is_redirected(void) {
  function mi_decl_export (line 797) | mi_decl_export void _mi_redirect_entry(DWORD reason) {
  function _mi_allocator_init (line 819) | bool _mi_allocator_init(const char** message) {
  function _mi_allocator_done (line 822) | void _mi_allocator_done(void) {

FILE: third-party/mimalloc/src/random.c
  function rotl (line 36) | static inline uint32_t rotl(uint32_t x, uint32_t shift) {
  function qround (line 40) | static inline void qround(uint32_t x[16], size_t a, size_t b, size_t c, ...
  function chacha_block (line 47) | static void chacha_block(mi_random_ctx_t* ctx)
  function chacha_next32 (line 81) | static uint32_t chacha_next32(mi_random_ctx_t* ctx) {
  function read32 (line 92) | static inline uint32_t read32(const uint8_t* p, size_t idx32) {
  function chacha_init (line 97) | static void chacha_init(mi_random_ctx_t* ctx, const uint8_t key[32], uin...
  function chacha_split (line 116) | static void chacha_split(mi_random_ctx_t* ctx, uint64_t nonce, mi_random...
  function mi_random_is_initialized (line 133) | static bool mi_random_is_initialized(mi_random_ctx_t* ctx) {
  function _mi_random_split (line 138) | void _mi_random_split(mi_random_ctx_t* ctx, mi_random_ctx_t* ctx_new) {
  function _mi_random_next (line 144) | uintptr_t _mi_random_next(mi_random_ctx_t* ctx) {
  function _mi_os_random_weak (line 161) | uintptr_t _mi_os_random_weak(uintptr_t extra_seed) {
  function mi_random_init_ex (line 173) | static void mi_random_init_ex(mi_random_ctx_t* ctx, bool use_weak) {
  function _mi_random_init (line 194) | void _mi_random_init(mi_random_ctx_t* ctx) {
  function _mi_random_init_weak (line 198) | void _mi_random_init_weak(mi_random_ctx_t * ctx) {
  function _mi_random_reinit_if_weak (line 202) | void _mi_random_reinit_if_weak(mi_random_ctx_t * ctx) {

FILE: third-party/mimalloc/src/segment-map.c
  type mi_segmap_part_t (line 42) | typedef struct mi_segmap_part_s {
  function mi_segmap_part_t (line 50) | static mi_segmap_part_t* mi_segment_map_index_of(const mi_segment_t* seg...
  function _mi_segment_map_allocated_at (line 82) | void _mi_segment_map_allocated_at(const mi_segment_t* segment) {
  function _mi_segment_map_freed_at (line 95) | void _mi_segment_map_freed_at(const mi_segment_t* segment) {
  function mi_segment_t (line 109) | static mi_segment_t* _mi_segment_of(const void* p) {
  function mi_is_valid_pointer (line 126) | static bool mi_is_valid_pointer(const void* p) {
  function mi_is_in_heap_region (line 131) | bool mi_is_in_heap_region(const void* p) mi_attr_noexcept {
  function _mi_segment_map_unsafe_destroy (line 135) | void _mi_segment_map_unsafe_destroy(void) {

FILE: third-party/mimalloc/src/segment.c
  function mi_commit_mask_all_set (line 27) | static bool mi_commit_mask_all_set(const mi_commit_mask_t* commit, const...
  function mi_commit_mask_any_set (line 34) | static bool mi_commit_mask_any_set(const mi_commit_mask_t* commit, const...
  function mi_commit_mask_create_intersect (line 41) | static void mi_commit_mask_create_intersect(const mi_commit_mask_t* comm...
  function mi_commit_mask_clear (line 47) | static void mi_commit_mask_clear(mi_commit_mask_t* res, const mi_commit_...
  function mi_commit_mask_set (line 53) | static void mi_commit_mask_set(mi_commit_mask_t* res, const mi_commit_ma...
  function mi_commit_mask_create (line 59) | static void mi_commit_mask_create(size_t bitidx, size_t bitcount, mi_com...
  function _mi_commit_mask_committed_size (line 86) | size_t _mi_commit_mask_committed_size(const mi_commit_mask_t* cm, size_t...
  function _mi_commit_mask_next_run (line 105) | size_t _mi_commit_mask_next_run(const mi_commit_mask_t* cm, size_t* idx) {
  function mi_slice_t (line 178) | static const mi_slice_t* mi_segment_slices_end(const mi_segment_t* segme...
  function mi_slice_bin8 (line 194) | static inline size_t mi_slice_bin8(size_t slice_count) {
  function mi_slice_bin (line 204) | static inline size_t mi_slice_bin(size_t slice_count) {
  function mi_slice_index (line 212) | static inline size_t mi_slice_index(const mi_slice_t* slice) {
  function mi_span_queue_push (line 224) | static void mi_span_queue_push(mi_span_queue_t* sq, mi_slice_t* slice) {
  function mi_span_queue_t (line 235) | static mi_span_queue_t* mi_span_queue_for(size_t slice_count, mi_segment...
  function mi_span_queue_delete (line 242) | static void mi_span_queue_delete(mi_span_queue_t* sq, mi_slice_t* slice) {
  function mi_slice_is_used (line 259) | static bool mi_slice_is_used(const mi_slice_t* slice) {
  function mi_span_queue_contains (line 265) | static bool mi_span_queue_contains(mi_span_queue_t* sq, mi_slice_t* slic...
  function mi_segment_is_valid (line 272) | static bool mi_segment_is_valid(mi_segment_t* segment, mi_segments_tld_t...
  function mi_segment_info_size (line 328) | static size_t mi_segment_info_size(mi_segment_t* segment) {
  function mi_segment_calculate_slices (line 370) | static size_t mi_segment_calculate_slices(size_t required, size_t* info_...
  function mi_segments_track_size (line 398) | static void mi_segments_track_size(long segment_size, mi_segments_tld_t*...
  function mi_segment_os_free (line 407) | static void mi_segment_os_free(mi_segment_t* segment, mi_segments_tld_t*...
  function mi_segment_commit_mask (line 437) | static void mi_segment_commit_mask(mi_segment_t* segment, bool conservat...
  function mi_segment_commit (line 487) | static bool mi_segment_commit(mi_segment_t* segment, uint8_t* p, size_t ...
  function mi_segment_ensure_committed (line 517) | static bool mi_segment_ensure_committed(mi_segment_t* segment, uint8_t* ...
  function mi_segment_purge (line 525) | static bool mi_segment_purge(mi_segment_t* segment, uint8_t* p, size_t s...
  function mi_segment_schedule_purge (line 554) | static void mi_segment_schedule_purge(mi_segment_t* segment, uint8_t* p,...
  function mi_segment_try_purge (line 594) | static void mi_segment_try_purge(mi_segment_t* segment, bool force) {
  function _mi_segment_collect (line 619) | void _mi_segment_collect(mi_segment_t* segment, bool force) {
  function mi_segment_is_abandoned (line 627) | static bool mi_segment_is_abandoned(mi_segment_t* segment) {
  function mi_segment_span_free (line 632) | static void mi_segment_span_free(mi_segment_t* segment, size_t slice_ind...
  function mi_segment_span_remove_from_queue (line 673) | static void mi_segment_span_remove_from_queue(mi_slice_t* slice, mi_segm...
  function mi_slice_t (line 681) | static mi_slice_t* mi_segment_span_free_coalesce(mi_slice_t* slice, mi_s...
  function mi_page_t (line 732) | static mi_page_t* mi_segment_span_allocate(mi_segment_t* segment, size_t...
  function mi_segment_slice_split (line 781) | static void mi_segment_slice_split(mi_segment_t* segment, mi_slice_t* sl...
  function mi_page_t (line 793) | static mi_page_t* mi_segments_page_find_and_allocate(size_t slice_count,...
  function mi_segment_t (line 832) | static mi_segment_t* mi_segment_os_alloc( size_t required, size_t page_a...
  function mi_segment_t (line 894) | static mi_segment_t* mi_segment_alloc(size_t required, size_t page_align...
  function mi_segment_free (line 973) | static void mi_segment_free(mi_segment_t* segment, bool force, mi_segmen...
  function mi_slice_t (line 1017) | static mi_slice_t* mi_segment_page_clear(mi_page_t* page, mi_segments_tl...
  function _mi_segment_page_free (line 1050) | void _mi_segment_page_free(mi_page_t* page, bool force, mi_segments_tld_...
  function mi_segment_abandon (line 1097) | static void mi_segment_abandon(mi_segment_t* segment, mi_segments_tld_t*...
  function _mi_segment_page_abandon (line 1134) | void _mi_segment_page_abandon(mi_page_t* page, mi_segments_tld_t* tld) {
  function mi_slice_t (line 1155) | static mi_slice_t* mi_slices_start_iterate(mi_segment_t* segment, const ...
  function mi_segment_check_free (line 1164) | static bool mi_segment_check_free(mi_segment_t* segment, size_t slices_n...
  function mi_segment_t (line 1208) | static mi_segment_t* mi_segment_reclaim(mi_segment_t* segment, mi_heap_t...
  function _mi_segment_attempt_reclaim (line 1280) | bool _mi_segment_attempt_reclaim(mi_heap_t* heap, mi_segment_t* segment) {
  function _mi_abandoned_reclaim_all (line 1301) | void _mi_abandoned_reclaim_all(mi_heap_t* heap, mi_segments_tld_t* tld) {
  function segment_count_is_within_target (line 1312) | static bool segment_count_is_within_target(mi_segments_tld_t* tld, size_...
  function mi_segment_get_reclaim_tries (line 1318) | static long mi_segment_get_reclaim_tries(mi_segments_tld_t* tld) {
  function mi_segment_t (line 1330) | static mi_segment_t* mi_segment_try_reclaim(mi_heap_t* heap, size_t need...
  function _mi_abandoned_collect (line 1380) | void _mi_abandoned_collect(mi_heap_t* heap, bool force, mi_segments_tld_...
  function mi_segment_force_abandon (line 1408) | static void mi_segment_force_abandon(mi_segment_t* segment, mi_segments_...
  function mi_segments_try_abandon_to_target (line 1462) | static void mi_segments_try_abandon_to_target(mi_heap_t* heap, size_t ta...
  function mi_segments_try_abandon (line 1482) | static void mi_segments_try_abandon(mi_heap_t* heap, mi_segments_tld_t* ...
  function mi_collect_reduce (line 1489) | void mi_collect_reduce(size_t target_size) mi_attr_noexcept {
  function mi_segment_t (line 1504) | static mi_segment_t* mi_segment_reclaim_or_alloc(mi_heap_t* heap, size_t...
  function mi_page_t (line 1532) | static mi_page_t* mi_segments_page_alloc(mi_heap_t* heap, mi_page_kind_t...
  function mi_page_t (line 1564) | static mi_page_t* mi_segment_huge_page_alloc(size_t size, size_t page_al...
  function _mi_segment_huge_page_free (line 1597) | void _mi_segment_huge_page_free(mi_segment_t* segment, mi_page_t* page, ...
  function _mi_segment_huge_page_reset (line 1625) | void _mi_segment_huge_page_reset(mi_segment_t* segment, mi_page_t* page,...
  function mi_page_t (line 1645) | mi_page_t* _mi_segment_page_alloc(mi_heap_t* heap, size_t block_size, si...
  function else (line 1653) | else if (block_size <= MI_SMALL_OBJ_SIZE_MAX) {
  function else (line 1656) | else if (block_size <= MI_MEDIUM_OBJ_SIZE_MAX) {
  function else (line 1659) | else if (block_size <= MI_LARGE_OBJ_SIZE_MAX) {
  function mi_segment_visit_page (line 1676) | static bool mi_segment_visit_page(mi_page_t* page, bool visit_blocks, mi...
  function _mi_segment_visit_blocks (line 1688) | bool _mi_segment_visit_blocks(mi_segment_t* segment, int heap_tag, bool ...

FILE: third-party/mimalloc/src/stats.c
  function mi_is_in_main (line 22) | static bool mi_is_in_main(void* stat) {
  function mi_stat_update (line 27) | static void mi_stat_update(mi_stat_count_t* stat, int64_t amount) {
  function _mi_stat_counter_increase (line 46) | void _mi_stat_counter_increase(mi_stat_counter_t* stat, size_t amount) {
  function _mi_stat_increase (line 55) | void _mi_stat_increase(mi_stat_count_t* stat, size_t amount) {
  function _mi_stat_decrease (line 59) | void _mi_stat_decrease(mi_stat_count_t* stat, size_t amount) {
  function mi_stat_count_add_mt (line 66) | static void mi_stat_count_add_mt(mi_stat_count_t* stat, const mi_stat_co...
  function mi_stat_counter_add_mt (line 76) | static void mi_stat_counter_add_mt(mi_stat_counter_t* stat, const mi_sta...
  function mi_stats_add (line 85) | static void mi_stats_add(mi_stats_t* stats, const mi_stats_t* src) {
  function mi_printf_amount (line 111) | static void mi_printf_amount(int64_t n, int64_t unit, mi_output_fun* out...
  function mi_print_amount (line 140) | static void mi_print_amount(int64_t n, int64_t unit, mi_output_fun* out,...
  function mi_print_count (line 144) | static void mi_print_count(int64_t n, int64_t unit, mi_output_fun* out, ...
  function mi_stat_print_ex (line 149) | static void mi_stat_print_ex(const mi_stat_count_t* stat, const char* ms...
  function mi_stat_print (line 191) | static void mi_stat_print(const mi_stat_count_t* stat, const char* msg, ...
  function mi_stat_peak_print (line 195) | static void mi_stat_peak_print(const mi_stat_count_t* stat, const char* ...
  function mi_stat_counter_print (line 201) | static void mi_stat_counter_print(const mi_stat_counter_t* stat, const c...
  function mi_stat_counter_print_avg (line 208) | static void mi_stat_counter_print_avg(const mi_stat_counter_t* stat, con...
  function mi_print_header (line 216) | static void mi_print_header(mi_output_fun* out, void* arg ) {
  function mi_stats_print_bins (line 221) | static void mi_stats_print_bins(const mi_stat_count_t* bins, size_t max,...
  type buffered_t (line 245) | typedef struct buffered_s {
  function mi_buffered_flush (line 253) | static void mi_buffered_flush(buffered_t* buf) {
  function mi_buffered_out (line 259) | static void mi_cdecl mi_buffered_out(const char* msg, void* arg) {
  function _mi_stats_print (line 275) | static void _mi_stats_print(mi_stats_t* stats, mi_output_fun* out0, void...
  function mi_stats_t (line 348) | static mi_stats_t* mi_stats_get_default(void) {
  function mi_stats_merge_from (line 353) | static void mi_stats_merge_from(mi_stats_t* stats) {
  function mi_stats_reset (line 360) | void mi_stats_reset(void) mi_attr_noexcept {
  function mi_stats_merge (line 367) | void mi_stats_merge(void) mi_attr_noexcept {
  function _mi_stats_done (line 371) | void _mi_stats_done(mi_stats_t* stats) {  // called from `mi_thread_done`
  function mi_stats_print_out (line 375) | void mi_stats_print_out(mi_output_fun* out, void* arg) mi_attr_noexcept {
  function mi_stats_print (line 380) | void mi_stats_print(void* out) mi_attr_noexcept {
  function mi_thread_stats_print_out (line 385) | void mi_thread_stats_print_out(mi_output_fun* out, void* arg) mi_attr_no...
  function mi_msecs_t (line 396) | mi_msecs_t _mi_clock_now(void) {
  function mi_msecs_t (line 400) | mi_msecs_t _mi_clock_start(void) {
  function mi_msecs_t (line 408) | mi_msecs_t _mi_clock_end(mi_msecs_t start) {
  function mi_decl_export (line 418) | mi_decl_export void mi_process_info(size_t* elapsed_msecs, size_t* user_...
  function mi_stats_get (line 448) | void mi_stats_get(size_t stats_size, mi_stats_t* stats) mi_attr_noexcept {
  type mi_heap_buf_t (line 461) | typedef struct mi_heap_buf_s {
  function mi_heap_buf_expand (line 468) | static bool mi_heap_buf_expand(mi_heap_buf_t* hbuf) {
  function mi_heap_buf_print (line 482) | static void mi_heap_buf_print(mi_heap_buf_t* hbuf, const char* msg) {
  function mi_heap_buf_print_count_bin (line 497) | static void mi_heap_buf_print_count_bin(mi_heap_buf_t* hbuf, const char*...
  function mi_heap_buf_print_count (line 513) | static void mi_heap_buf_print_count(mi_heap_buf_t* hbuf, const char* pre...
  function mi_heap_buf_print_count_value (line 520) | static void mi_heap_buf_print_count_value(mi_heap_buf_t* hbuf, const cha...
  function mi_heap_buf_print_value (line 528) | static void mi_heap_buf_print_value(mi_heap_buf_t* hbuf, const char* nam...
  function mi_heap_buf_print_size (line 535) | static void mi_heap_buf_print_size(mi_heap_buf_t* hbuf, const char* name...
  function mi_heap_buf_print_counter_value (line 542) | static void mi_heap_buf_print_counter_value(mi_heap_buf_t* hbuf, const c...

FILE: third-party/mimalloc/test/main-override-dep.h
  function class (line 7) | class TestAllocInDll

FILE: third-party/mimalloc/test/main-override-static.c
  function main (line 32) | int main() {
  function test_align (line 87) | static void test_align() {
  function invalid_free (line 94) | static void invalid_free() {
  function block_overflow1 (line 99) | static void block_overflow1() {
  function block_overflow2 (line 105) | static void block_overflow2() {
  function double_free1 (line 114) | static void double_free1() {
  function double_free2 (line 130) | static void double_free2() {
  function corrupt_free (line 153) | static void corrupt_free() {
  function test_aslr (line 177) | static void test_aslr(void) {
  function test_process_info (line 184) | static void test_process_info(void) {
  function test_reserved (line 201) | static void test_reserved(void) {
  function negative_stat (line 219) | static void negative_stat(void) {
  function alloc_huge (line 227) | static void alloc_huge(void) {
  function test_visit (line 232) | static bool test_visit(const mi_heap_t* heap, const mi_heap_area_t* area...
  function test_heap_walk (line 242) | static void test_heap_walk(void) {
  function test_heap_arena (line 251) | static void test_heap_arena(void) {
  function test_canary_leak (line 265) | static void test_canary_leak(void) {
  function test_manage_os_memory (line 275) | static void test_manage_os_memory(void) {
  function test_manage_os_memory (line 297) | static void test_manage_os_memory(void) {
  function test_large_pages (line 310) | static void test_large_pages(void) {
  function mi_bsr32 (line 357) | static inline uint8_t mi_bsr32(uint32_t x) {
  function mi_bsr32 (line 363) | static inline uint8_t mi_bsr32(uint32_t x) {
  function mi_bsr32 (line 367) | static inline uint8_t mi_bsr32(uint32_t x) {
  function _mi_bsr (line 385) | uint8_t _mi_bsr(uintptr_t x) {
  function _mi_wsize_from_size (line 399) | static inline size_t _mi_wsize_from_size(size_t size) {
  function mi_bin (line 409) | static inline size_t mi_bin(size_t wsize) {
  function _mi_bin4 (line 449) | static inline uint8_t _mi_bin4(size_t size) {
  function _mi_binx4 (line 478) | static size_t _mi_binx4(size_t wsize) {
  function _mi_binx8 (line 495) | static size_t _mi_binx8(size_t bsize) {
  function mi_binx (line 504) | static inline size_t mi_binx(size_t wsize) {
  function mi_bins (line 526) | static void mi_bins(void) {

FILE: third-party/mimalloc/test/main-override.c
  function main (line 8) | int main() {

FILE: third-party/mimalloc/test/main-override.cpp
  function msleep (line 18) | static void msleep(unsigned long msecs) { Sleep(msecs); }
  function msleep (line 21) | static void msleep(unsigned long msecs) { usleep(msecs * 1000UL); }
  function main (line 50) | int main() {
  function free_p (line 82) | void free_p() {
  class Test (line 87) | class Test {
    method Test (line 91) | Test(int x) { i = x; }
  function various_tests (line 96) | static void various_tests() {
  class Static (line 126) | class Static {
    method Static (line 130) | Static() {
  function test_stl_allocator1 (line 143) | static bool test_stl_allocator1() {
  type some_struct (line 150) | struct some_struct { int i; int j; double z; }
  function test_dep (line 154) | static void test_dep()
  function test_stl_allocator2 (line 162) | static bool test_stl_allocator2() {
  function test_stl_allocator3 (line 170) | static bool test_stl_allocator3() {
  function test_stl_allocator4 (line 177) | static bool test_stl_allocator4() {
  function test_stl_allocator5 (line 184) | static bool test_stl_allocator5() {
  function test_stl_allocator6 (line 191) | static bool test_stl_allocator6() {
  function test_stl_allocators (line 199) | static void test_stl_allocators() {
  function test_mixed0 (line 218) | static void test_mixed0() {
  function asd (line 248) | void asd() {
  function test_mixed1 (line 252) | static void test_mixed1() {
  function test_large_migrate (line 275) | static void test_large_migrate(void) {
  function strdup_test (line 294) | static void strdup_test() {
  function heap_no_delete_worker (line 306) | static void heap_no_delete_worker() {
  function heap_no_delete (line 312) | static void heap_no_delete() {
  function test_std_string (line 319) | static void test_std_string() {
  function t1main (line 328) | static void t1main() {
  function heap_late_free (line 334) | static void heap_late_free() {
  function alloc0 (line 346) | static void alloc0(/* void* arg */)
  function padding_shrink (line 351) | static void padding_shrink(void)
  function heap_thread_free_large_worker (line 360) | static void heap_thread_free_large_worker() {
  function heap_thread_free_large (line 364) | static void heap_thread_free_large() {
  function heap_thread_free_huge_worker (line 372) | static void heap_thread_free_huge_worker() {
  function heap_thread_free_huge (line 376) | static void heap_thread_free_huge() {
  function test_mt_shutdown (line 384) | static void test_mt_shutdown()
  function large_alloc (line 411) | void large_alloc(void)
  function fail_aslr (line 421) | static void fail_aslr() {
  function dummy_worker (line 429) | static void dummy_worker() {
  function tsan_numa_test (line 434) | static void tsan_numa_test() {
  function bench_alloc_large (line 445) | static void bench_alloc_large(void) {
  class MTest (line 471) | class MTest
    method MTest (line 475) | MTest() { data = (char*)malloc(1024); }
  function threadFun (line 481) | void threadFun( int i )
  function test_thread_local (line 487) | void test_thread_local()

FILE: third-party/mimalloc/test/main.c
  function test_heap (line 5) | void test_heap(void* p_out) {
  function test_large (line 14) | void test_large() {
  function main (line 25) | int main() {

FILE: third-party/mimalloc/test/test-api-fill.c
  function main (line 24) | int main(void) {
  function check_zero_init (line 301) | bool check_zero_init(uint8_t* p, size_t size) {
  function check_debug_fill_uninit (line 312) | bool check_debug_fill_uninit(uint8_t* p, size_t size) {
  function check_debug_fill_freed (line 328) | bool check_debug_fill_freed(uint8_t* p, size_t size) {

FILE: third-party/mimalloc/test/test-api.c
  function mem_is_zero (line 54) | bool mem_is_zero(uint8_t* p, size_t size) {
  function main (line 65) | int main(void) {
  function test_heap1 (line 362) | bool test_heap1(void) {
  function test_heap2 (line 371) | bool test_heap2(void) {
  function test_stl_allocator1 (line 382) | bool test_stl_allocator1(void) {
  type some_struct (line 393) | struct some_struct  { int i; int j; double z; }
  function test_stl_allocator2 (line 395) | bool test_stl_allocator2(void) {
  function test_stl_heap_allocator1 (line 406) | bool test_stl_heap_allocator1(void) {
  function test_stl_heap_allocator2 (line 417) | bool test_stl_heap_allocator2(void) {
  function test_stl_heap_allocator3 (line 428) | bool test_stl_heap_allocator3(void) {
  function test_stl_heap_allocator4 (line 446) | bool test_stl_heap_allocator4(void) {

FILE: third-party/mimalloc/test/test-stress.c
  function pick (line 89) | static uintptr_t pick(random_t r) {
  function chance (line 110) | static bool chance(size_t perc, random_t r) {
  function free_items (line 133) | static void free_items(void* p) {
  function visit_blocks (line 148) | static bool visit_blocks(const mi_heap_t* heap, const mi_heap_area_t* ar...
  function stress (line 158) | static void stress(intptr_t tid) {
  function test_stress (line 222) | static void test_stress(void) {
  function leak (line 251) | static void leak(intptr_t tid) {
  function test_leak (line 261) | static void test_leak(void) {
  function main (line 279) | int main(int argc, char** argv) {
  function DWORD (line 359) | static DWORD WINAPI thread_entry(LPVOID param) {
  function run_os_threads (line 364) | static void run_os_threads(size_t nthreads, void (*fun)(intptr_t)) {
  function run_os_threads (line 399) | static void run_os_threads(size_t nthreads, void (*fun)(intptr_t)) {

FILE: third-party/mimalloc/test/test-wrong.c
  function main (line 55) | int main(int argc, char** argv) {

FILE: third-party/mimalloc/test/testhelper.h
  function check_result (line 20) | static bool check_result(bool result, const char* testname, const char* ...
  function print_test_summary (line 41) | static inline int print_test_summary(void)

FILE: third-party/rust-demangle/rust-demangle.c
  type rust_demangler (line 9) | struct rust_demangler {
  function peek (line 52) | static char peek(const struct rust_demangler *rdm) {
  function eat (line 58) | static bool eat(struct rust_demangler *rdm, char c) {
  function next (line 66) | static char next(struct rust_demangler *rdm) {
  type hex_nibbles (line 73) | struct hex_nibbles {
  function parse_hex_nibbles (line 78) | static struct hex_nibbles parse_hex_nibbles(struct rust_demangler *rdm) {
  function parse_hex_nibbles_for_const_uint (line 96) | static struct hex_nibbles
  function parse_hex_nibbles_for_const_bytes (line 110) | static struct hex_nibbles
  function decode_hex_nibble (line 117) | static uint8_t decode_hex_nibble(char nibble) {
  function parse_integer_62 (line 121) | static uint64_t parse_integer_62(struct rust_demangler *rdm) {
  function parse_opt_integer_62 (line 141) | static uint64_t parse_opt_integer_62(struct rust_demangler *rdm, char ta...
  function parse_disambiguator (line 147) | static uint64_t parse_disambiguator(struct rust_demangler *rdm) {
  type rust_mangled_ident (line 151) | struct rust_mangled_ident {
  function parse_ident (line 161) | static struct rust_mangled_ident parse_ident(struct rust_demangler *rdm) {
  function print_str (line 218) | static void
  function print_uint64 (line 226) | static void print_uint64(struct rust_demangler *rdm, uint64_t x) {
  function print_uint64_hex (line 232) | static void print_uint64_hex(struct rust_demangler *rdm, uint64_t x) {
  function print_quoted_escaped_char (line 238) | static void
  function print_ident (line 295) | static void
  function print_lifetime_from_index (line 428) | static void print_lifetime_from_index(struct rust_demangler *rdm, uint64...
  type rust_demangler (line 449) | struct rust_demangler
  type rust_demangler (line 450) | struct rust_demangler
  type rust_demangler (line 451) | struct rust_demangler
  type rust_demangler (line 452) | struct rust_demangler
  type rust_demangler (line 453) | struct rust_demangler
  type rust_demangler (line 454) | struct rust_demangler
  type rust_demangler (line 455) | struct rust_demangler
  type rust_demangler (line 456) | struct rust_demangler
  type rust_demangler (line 457) | struct rust_demangler
  function demangle_binder (line 462) | static void demangle_binder(struct rust_demangler *rdm) {
  function demangle_path (line 478) | static void demangle_path(struct rust_demangler *rdm, bool in_value) {
  function demangle_generic_arg (line 579) | static void demangle_generic_arg(struct rust_demangler *rdm) {
  function demangle_type (line 639) | static void demangle_type(struct rust_demangler *rdm) {
  function demangle_path_maybe_open_generics (line 797) | static bool demangle_path_maybe_open_generics(struct rust_demangler *rdm) {
  function demangle_dyn_trait (line 824) | static void demangle_dyn_trait(struct rust_demangler *rdm) {
  function demangle_const (line 846) | static void demangle_const(struct rust_demangler *rdm, bool in_value) {
  function demangle_const_uint (line 1072) | static void demangle_const_uint(struct rust_demangler *rdm, char ty_tag) {
  type utf8_byte (line 1094) | struct utf8_byte {
  function utf8_decode (line 1105) | static struct utf8_byte utf8_decode(uint8_t byte) {
  function demangle_const_str_literal (line 1125) | static void demangle_const_str_literal(struct rust_demangler *rdm) {
  function is_rust_hash (line 1155) | static bool is_rust_hash(struct rust_mangled_ident name) {
  function print_legacy_ident (line 1168) | static void print_legacy_ident(
  function demangle_legacy_path (line 1287) | static void demangle_legacy_path(struct rust_demangler *rdm) {
  function rust_demangle_with_callback (line 1315) | bool rust_demangle_with_callback(
  type str_buf (line 1414) | struct str_buf {
  function str_buf_reserve (line 1421) | static void str_buf_reserve(struct str_buf *buf, size_t extra) {
  function str_buf_append (line 1468) | static void str_buf_append(struct str_buf *buf, const char *data, size_t...
  function str_buf_demangle_callback (line 1477) | static void
  type str_buf (line 1483) | struct str_buf

FILE: third-party/rust-demangle/test-harness/build.rs
  function main (line 1) | fn main() {

FILE: third-party/rust-demangle/test-harness/examples/check-csv-dataset.rs
  function main (line 11) | fn main() {

FILE: third-party/rust-demangle/test-harness/src/lib.rs
  type Demangle (line 34) | pub struct Demangle<'a> {
  function demangle (line 43) | pub fn demangle(s: &str) -> Demangle {
  function try_demangle (line 50) | pub fn try_demangle(s: &str) -> Result<Demangle<'_>, rustc_demangle::Try...
  function fmt (line 65) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function equal_modulo_unicode_escapes (line 73) | fn equal_modulo_unicode_escapes(a: &str, b: &str) -> bool {
  function to_string_maybe_verbose (line 101) | pub fn to_string_maybe_verbose(&self, verbose: bool) -> String {
  function demangle_via_c (line 123) | fn demangle_via_c(mangled: &str, verbose: bool) -> Result<String, ()> {

FILE: third-party/rust-demangle/test-harness/tests/legacy.rs
  function ok (line 29) | fn ok(sym: &str, expected: &str) -> bool {
  function ok_err (line 46) | fn ok_err(sym: &str) -> bool {
  function demangle (line 57) | fn demangle() {
  function demangle_dollars (line 65) | fn demangle_dollars() {
  function demangle_many_dollars (line 74) | fn demangle_many_dollars() {
  function demangle_osx (line 80) | fn demangle_osx() {
  function demangle_windows (line 90) | fn demangle_windows() {
  function demangle_elements_beginning_with_underscore (line 97) | fn demangle_elements_beginning_with_underscore() {
  function demangle_trait_impls (line 104) | fn demangle_trait_impls() {
  function demangle_without_hash (line 112) | fn demangle_without_hash() {
  function demangle_without_hash_edgecases (line 119) | fn demangle_without_hash_edgecases() {
  function demangle_thinlto (line 137) | fn demangle_thinlto() {
  function demangle_llvm_ir_branch_labels (line 148) | fn demangle_llvm_ir_branch_labels() {
  function demangle_ignores_suffix_that_doesnt_look_like_a_symbol (line 154) | fn demangle_ignores_suffix_that_doesnt_look_like_a_symbol() {
  function dont_panic (line 159) | fn dont_panic() {
  function invalid_no_chop (line 174) | fn invalid_no_chop() {
  function handle_assoc_types (line 179) | fn handle_assoc_types() {
  function handle_bang (line 184) | fn handle_bang() {
  function demangle_utf8_idents (line 192) | fn demangle_utf8_idents() {
  function demangle_issue_60925 (line 200) | fn demangle_issue_60925() {

FILE: third-party/rust-demangle/test-harness/tests/top_level.rs
  function ok (line 32) | fn ok(sym: &str, expected: &str) -> bool {
  function ok_err (line 49) | fn ok_err(sym: &str) -> bool {
  function demangle (line 60) | fn demangle() {
  function demangle_dollars (line 68) | fn demangle_dollars() {
  function demangle_many_dollars (line 77) | fn demangle_many_dollars() {
  function demangle_osx (line 83) | fn demangle_osx() {
  function demangle_windows (line 93) | fn demangle_windows() {
  function demangle_elements_beginning_with_underscore (line 100) | fn demangle_elements_beginning_with_underscore() {
  function demangle_trait_impls (line 107) | fn demangle_trait_impls() {
  function demangle_without_hash (line 115) | fn demangle_without_hash() {
  function demangle_without_hash_edgecases (line 122) | fn demangle_without_hash_edgecases() {
  function demangle_thinlto (line 140) | fn demangle_thinlto() {
  function demangle_llvm_ir_branch_labels (line 151) | fn demangle_llvm_ir_branch_labels() {
  function demangle_ignores_suffix_that_doesnt_look_like_a_symbol (line 157) | fn demangle_ignores_suffix_that_doesnt_look_like_a_symbol() {
  function dont_panic (line 162) | fn dont_panic() {
  function invalid_no_chop (line 177) | fn invalid_no_chop() {
  function handle_assoc_types (line 182) | fn handle_assoc_types() {
  function handle_bang (line 187) | fn handle_bang() {
  function limit_recursion (line 197) | fn limit_recursion() {
  function limit_output_oom_hazard (line 211) | fn limit_output_oom_hazard() {
  function limit_output (line 222) | fn limit_output() {

FILE: third-party/rust-demangle/test-harness/tests/v0.rs
  function demangle_crate_with_leading_digit (line 52) | fn demangle_crate_with_leading_digit() {
  function demangle_utf8_idents (line 57) | fn demangle_utf8_idents() {
  function demangle_closure (line 65) | fn demangle_closure() {
  function demangle_dyn_trait (line 77) | fn demangle_dyn_trait() {
  function demangle_const_generics_preview (line 85) | fn demangle_const_generics_preview() {
  function demangle_min_const_generics (line 96) | fn demangle_min_const_generics() {
  function demangle_const_str (line 111) | fn demangle_const_str() {
  function demangle_const_ref_str (line 132) | fn demangle_const_ref_str() {
  function demangle_const_ref (line 150) | fn demangle_const_ref() {
  function demangle_const_array (line 161) | fn demangle_const_array() {
  function demangle_const_tuple (line 170) | fn demangle_const_tuple() {
  function demangle_const_adt (line 181) | fn demangle_const_adt() {
  function demangle_exponential_explosion (line 197) | fn demangle_exponential_explosion() {
  function demangle_thinlto (line 213) | fn demangle_thinlto() {
  function demangle_extra_suffix (line 220) | fn demangle_extra_suffix() {
  function demangling_limits (line 231) | fn demangling_limits() {
  function recursion_limit_leaks (line 257) | fn recursion_limit_leaks() {
  function recursion_limit_backref_free_bypass (line 282) | fn recursion_limit_backref_free_bypass() {

FILE: third-party/tbb/doc/main/reference/examples/blocked_nd_range_ctad_example.cpp
  function main (line 22) | int main() {
  function main (line 60) | int main() {}

FILE: third-party/tbb/doc/main/reference/examples/custom_mutex_chmap_example.cpp
  class SharedMutexWrapper (line 24) | class SharedMutexWrapper {
    class scoped_lock (line 32) | class scoped_lock {
      method scoped_lock (line 34) | scoped_lock() : my_mutex_ptr(nullptr), my_writer_flag(false) {}
      method scoped_lock (line 35) | scoped_lock(SharedMutexWrapper& mutex, bool write = true)
      method acquire (line 49) | void acquire(SharedMutexWrapper& mutex, bool write = true) {
      method try_acquire (line 62) | bool try_acquire(SharedMutexWrapper& mutex, bool write = true) {
      method release (line 79) | void release() {
      method upgrade_to_writer (line 87) | bool upgrade_to_writer() {
      method downgrade_to_reader (line 96) | bool downgrade_to_reader() {
      method is_writer (line 104) | bool is_writer() const {
  function main (line 116) | int main() {
  function main (line 128) | int main() {}

FILE: third-party/tbb/doc/main/reference/examples/fixed_pool_example.cpp
  function main (line 21) | int main() {

FILE: third-party/tbb/doc/main/reference/examples/helpers_for_expressing_graphs_preview_api_example.cpp
  function main (line 23) | int main() {
  function main (line 53) | int main() {}

FILE: third-party/tbb/doc/main/reference/examples/helpers_for_expressing_graphs_regular_api_example.cpp
  function main (line 22) | int main() {
  function main (line 59) | int main() {}

FILE: third-party/tbb/doc/main/reference/examples/make_edges_function_example.cpp
  function main (line 23) | int main() {
  function main (line 48) | int main() {}

FILE: third-party/tbb/doc/main/reference/examples/malloc_replacement_log_example.cpp
  function main (line 23) | int main(){
  function main (line 40) | int main() {}

FILE: third-party/tbb/doc/main/reference/examples/memory_pool_allocator_example.cpp
  function main (line 22) | int main() {

FILE: third-party/tbb/doc/main/reference/examples/memory_pool_example.cpp
  function main (line 21) | int main() {

FILE: third-party/tbb/doc/main/reference/examples/parallel_phase_example.cpp
  function main (line 26) | int main() {

FILE: third-party/tbb/doc/main/reference/examples/parallel_sort_ranges_extension_example.cpp
  function get_span (line 24) | std::span<int> get_span() {
  function main (line 29) | int main() {
  function main (line 36) | int main() {}

FILE: third-party/tbb/doc/main/reference/examples/rvalue_reduce.cpp
  function main (line 26) | int main() {
  function main (line 49) | int main() {}

FILE: third-party/tbb/doc/main/reference/examples/try_put_and_wait_example.cpp
  type f1_body (line 20) | struct f1_body {
  type f2_body (line 24) | struct f2_body : f1_body {}
  type f3_body (line 25) | struct f3_body : f1_body {}
  type f4_body (line 27) | struct f4_body {
  type f1_body (line 39) | struct f1_body
  type f2_body (line 40) | struct f2_body
  type f3_body (line 41) | struct f3_body
  type f4_body (line 42) | struct f4_body
  function main (line 44) | int main() {

FILE: third-party/tbb/doc/main/tbb_userguide/examples/blocked_nd_range_example.cpp
  function kernel3d (line 22) | float kernel3d(const Features& feature_maps, int i, int j, int k,
  function convolution3d (line 35) | void convolution3d(const Features& feature_maps, Output& out,
  function main (line 60) | int main() {

FILE: third-party/tbb/doc/main/tbb_userguide/examples/flow_graph_examples.cpp
  function flow_graph_attach_to_arena_1 (line 27) | static void flow_graph_attach_to_arena_1() {
  function flow_graph_attach_to_arena_2 (line 47) | static void flow_graph_attach_to_arena_2() {
  function main (line 67) | int main() {

FILE: third-party/tbb/doc/main/tbb_userguide/examples/parallel_for_lambda_example_1.cpp
  function Foo (line 17) | void Foo(float) {}
  function ParallelApplyFoo (line 24) | void ParallelApplyFoo( float* a, size_t n ) {
  function main (line 34) | int main() {

FILE: third-party/tbb/doc/main/tbb_userguide/examples/parallel_for_lambda_example_2.cpp
  function Foo (line 17) | void Foo(float) {}
  function ParallelApplyFoo (line 26) | void ParallelApplyFoo(float a[], size_t n) {
  function main (line 31) | int main() {

FILE: third-party/tbb/doc/main/tbb_userguide/examples/parallel_for_os_example.cpp
  function Foo (line 17) | void Foo(float) {}
  class ApplyFoo (line 24) | class ApplyFoo {
    method ApplyFoo (line 32) | ApplyFoo( float a[] ) :
  function ParallelApplyFoo (line 41) | void ParallelApplyFoo( float a[], size_t n ) {
  function main (line 46) | int main() {

FILE: third-party/tbb/doc/main/tbb_userguide/snippets/blocked_nd_range_example.cpp
  function main (line 5) | int main() {

FILE: third-party/tbb/doc/main/tbb_userguide/snippets/flow_graph_examples.cpp
  function flow_graph_attach_to_arena_1 (line 27) | static void flow_graph_attach_to_arena_1() {
  function flow_graph_attach_to_arena_2 (line 47) | static void flow_graph_attach_to_arena_2() {
  function main (line 67) | int main() {

FILE: third-party/tbb/examples/common/gui/convideo.cpp
  type timeval (line 41) | struct timeval
  type timezone (line 81) | struct timezone
  type timeval (line 82) | struct timeval
  type timezone (line 110) | struct timezone

FILE: third-party/tbb/examples/common/gui/d2dvideo.cpp
  function DisplayError (line 42) | bool DisplayError(LPSTR lpstrErr, HRESULT hres) {
  function DrawBitmap (line 57) | void DrawBitmap() {
  function mouse (line 70) | inline void mouse(int k, LPARAM lParam) {
  function LRESULT (line 79) | LRESULT CALLBACK InternalWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LP...

FILE: third-party/tbb/examples/common/gui/gdivideo.cpp
  function DisplayError (line 33) | bool DisplayError(LPSTR lpstrErr, HRESULT hres) {
  function LRESULT (line 57) | LRESULT CALLBACK InternalWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LP...

FILE: third-party/tbb/examples/common/gui/macvideo.cpp
  type timeval (line 33) | struct timeval
  type timezone (line 81) | struct timezone
  type timeval (line 82) | struct timeval
  type timezone (line 104) | struct timezone
  type timezone (line 109) | struct timezone
  type timeval (line 110) | struct timeval
  function on_mouse_func (line 137) | void on_mouse_func(int x, int y, int k) {
  function on_key_func (line 142) | void on_key_func(int x) {

FILE: third-party/tbb/examples/common/gui/video.hpp
  class drawing_memory (line 38) | class drawing_memory {
    method get_size (line 49) | inline int get_size() const {
    method set_address (line 53) | inline void set_address(char *mem) {
  class video (line 62) | class video {
    method on_mouse (line 103) | virtual void on_mouse(int x, int y, int key) {}
    method on_key (line 105) | virtual void on_key(int key) {}
    method on_process (line 107) | virtual void on_process() {
  class drawing_area (line 125) | class drawing_area {
    method set_pixel (line 145) | void set_pixel(int localx, int localy, color_t color) {
  function drawing_memory (line 155) | inline drawing_memory video::get_drawing_memory() const {
    method get_size (line 49) | inline int get_size() const {
    method set_address (line 53) | inline void set_address(char *mem) {
  function WinMain (line 238) | int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, PSTR szCmdLine, int i...

FILE: third-party/tbb/examples/common/gui/winvideo.hpp
  function WinInit (line 64) | bool WinInit(HINSTANCE hInstance,
  function RedirectIOToConsole (line 110) | static bool RedirectIOToConsole(void) {
  function DWORD (line 196) | DWORD WINAPI thread_video(LPVOID lpParameter) {
  function loop_once (line 202) | static bool loop_once(video *v) {

FILE: third-party/tbb/examples/common/gui/xcode/tbbExample/OpenGLView.h
  function interface (line 24) | interface OpenGLView : UIView {
  function interface (line 42) | interface OpenGLView : NSOpenGLView{

FILE: third-party/tbb/examples/common/gui/xcode/tbbExample/tbbAppDelegate.h
  function interface (line 37) | interface tbbAppDelegate : NSObject <NSApplicationDelegate>{

FILE: third-party/tbb/examples/common/gui/xvideo.cpp
  type timeval (line 75) | struct timeval
  function mask2bits (line 89) | inline void mask2bits(unsigned int mask, unsigned int &save, depth_t &sh...
  function xerr_handler (line 104) | int xerr_handler(Display *dpy_, XErrorEvent *error) {
  type timezone (line 349) | struct timezone
  type timezone (line 384) | struct timezone
  type timeval (line 385) | struct timeval

FILE: third-party/tbb/examples/common/utility/fast_random.hpp
  type utility (line 22) | namespace utility {
    type internal (line 27) | namespace internal {
      function GetPrime (line 68) | std::size_t GetPrime(std::size_t seed) {
    class FastRandom (line 33) | class FastRandom {
      method get (line 38) | unsigned short get() {
      method get (line 42) | unsigned short get(std::size_t& seed) {
      method FastRandom (line 48) | FastRandom(std::size_t seed) {
    type internal (line 56) | namespace internal {
      function GetPrime (line 68) | std::size_t GetPrime(std::size_t seed) {
  type utility (line 55) | namespace utility {
    type internal (line 27) | namespace internal {
      function GetPrime (line 68) | std::size_t GetPrime(std::size_t seed) {
    class FastRandom (line 33) | class FastRandom {
      method get (line 38) | unsigned short get() {
      method get (line 42) | unsigned short get(std::size_t& seed) {
      method FastRandom (line 48) | FastRandom(std::size_t seed) {
    type internal (line 56) | namespace internal {
      function GetPrime (line 68) | std::size_t GetPrime(std::size_t seed) {

FILE: third-party/tbb/examples/common/utility/get_default_num_threads.hpp
  type utility (line 22) | namespace utility {
    function get_default_num_threads (line 23) | inline int get_default_num_threads() {

FILE: third-party/tbb/examples/common/utility/utility.hpp
  type utility (line 39) | namespace utility {
    type internal (line 40) | namespace internal {
      function dest_type (line 44) | dest_type& string_to(std::string const& s, dest_type& result) {
      function dest_type (line 54) | dest_type string_to(std::string const& s) {
      type is_bool (line 60) | struct is_bool {
        method value (line 61) | static bool value() {
      type is_bool<bool> (line 66) | struct is_bool<bool> {
        method value (line 67) | static bool value() {
      class type_base (line 72) | class type_base {
        method type_base (line 79) | type_base(std::string a_name, std::string a_description)
      class type_impl (line 88) | class type_impl : public type_base {
        method type_impl (line 90) | type_impl(const type_impl& src)
        method type_impl (line 100) | type_impl(std::string a_name,
        method parse_and_store (line 107) | void parse_and_store(const std::string& s) /*override*/ {
        method is_null_c_str (line 135) | static bool is_null_c_str(t&) {
        method is_null_c_str (line 138) | static bool is_null_c_str(char* s) {
        method value (line 141) | std::string value() const /*override*/ {
        method clone (line 147) | std::unique_ptr<type_base> clone() const /*override*/ {
      class argument (line 152) | class argument {
        method argument (line 158) | argument(argument const& other)
        method argument (line 161) | argument& operator=(argument a) {
        method swap (line 165) | void swap(argument& other) {
        method argument (line 170) | argument(std::string a_name,
        method value (line 176) | std::string value() const {
        method name (line 179) | std::string name() const {
        method description (line 182) | std::string description() const {
        method parse_and_store (line 185) | void parse_and_store(const std::string& s) {
        method is_matched (line 189) | bool is_matched() const {
      function is_power_of_2 (line 416) | bool is_power_of_2(T val) {
      function step_function_plus (line 420) | int step_function_plus(int previous, double step) {
      function step_function_multiply (line 423) | int step_function_multiply(int previous, double multiply) {
      function step_function_power2_ladder (line 429) | int step_function_power2_ladder(int previous, double nsteps) {
      type step_function_descriptor (line 451) | struct step_function_descriptor {
        method step_function_descriptor (line 456) | step_function_descriptor(char a_mnemonic, step_function_ptr_type a...
      function array_length (line 470) | inline std::size_t array_length(const T (&)[N]) {
      type thread_range_step (line 474) | struct thread_range_step {
        method thread_range_step (line 478) | thread_range_step(step_function_ptr_type step_function_, double st...
    class cli_argument_pack (line 195) | class cli_argument_pack {
      method add_arg (line 207) | void add_arg(internal::argument const& a) {
      method cli_argument_pack (line 219) | cli_argument_pack& arg(type& dest,
      method cli_argument_pack (line 234) | cli_argument_pack& positional_arg(type& dest,
      method parse (line 247) | void parse(std::size_t argc, char const* argv[]) {
      method usage_string (line 318) | std::string usage_string(const std::string& binary_name) const {
    class measurements (line 362) | class measurements {
      method measurements (line 364) | measurements() = default;
      method measurements (line 366) | measurements(unsigned iterations) {
      method start (line 370) | inline void start() {
      method stop (line 373) | inline void stop() {
      method computeRelError (line 378) | double computeRelError() {
    type internal (line 414) | namespace internal {
      function dest_type (line 44) | dest_type& string_to(std::string const& s, dest_type& result) {
      function dest_type (line 54) | dest_type string_to(std::string const& s) {
      type is_bool (line 60) | struct is_bool {
        method value (line 61) | static bool value() {
      type is_bool<bool> (line 66) | struct is_bool<bool> {
        method value (line 67) | static bool value() {
      class type_base (line 72) | class type_base {
        method type_base (line 79) | type_base(std::string a_name, std::string a_description)
      class type_impl (line 88) | class type_impl : public type_base {
        method type_impl (line 90) | type_impl(const type_impl& src)
        method type_impl (line 100) | type_impl(std::string a_name,
        method parse_and_store (line 107) | void parse_and_store(const std::string& s) /*override*/ {
        method is_null_c_str (line 135) | static bool is_null_c_str(t&) {
        method is_null_c_str (line 138) | static bool is_null_c_str(char* s) {
        method value (line 141) | std::string value() const /*override*/ {
        method clone (line 147) | std::unique_ptr<type_base> clone() const /*override*/ {
      class argument (line 152) | class argument {
        method argument (line 158) | argument(argument const& other)
        method argument (line 161) | argument& operator=(argument a) {
        method swap (line 165) | void swap(argument& other) {
        method argument (line 170) | argument(std::string a_name,
        method value (line 176) | std::string value() const {
        method name (line 179) | std::string name() const {
        method description (line 182) | std::string description() const {
        method parse_and_store (line 185) | void parse_and_store(const std::string& s) {
        method is_matched (line 189) | bool is_matched() const {
      function is_power_of_2 (line 416) | bool is_power_of_2(T val) {
      function step_function_plus (line 420) | int step_function_plus(int previous, double step) {
      function step_function_multiply (line 423) | int step_function_multiply(int previous, double multiply) {
      function step_function_power2_ladder (line 429) | int step_function_power2_ladder(int previous, double nsteps) {
      type step_function_descriptor (line 451) | struct step_function_descriptor {
        method step_function_descriptor (line 456) | step_function_descriptor(char a_mnemonic, step_function_ptr_type a...
      function array_length (line 470) | inline std::size_t array_length(const T (&)[N]) {
      type thread_range_step (line 474) | struct thread_range_step {
        method thread_range_step (line 478) | thread_range_step(step_function_ptr_type step_function_, double st...
    type thread_number_range (line 513) | struct thread_number_range {
      method thread_number_range (line 520) | thread_number_range(
      type string_to_number_of_threads (line 542) | struct string_to_number_of_threads {
        method string_to_number_of_threads (line 544) | string_to_number_of_threads(int auto_value_) : auto_value(auto_val...
    function report_elapsed_time (line 595) | inline void report_elapsed_time(double seconds) {
    function report_skipped (line 600) | inline void report_skipped() {
    function report_relative_error (line 605) | inline void report_relative_error(double err) {
    function parse_cli_arguments (line 610) | inline void parse_cli_arguments(int argc, const char* argv[], utility:...
    function parse_cli_arguments (line 630) | inline void parse_cli_arguments(int argc, char* argv[], utility::cli_a...

FILE: third-party/tbb/examples/concurrent_hash_map/count_strings/count_strings.cpp
  type std (line 27) | namespace std {
    class hash<std::basic_string<CharT, Traits, Allocator>> (line 30) | class hash<std::basic_string<CharT, Traits, Allocator>> {
  type Tally (line 82) | struct Tally {
    method Tally (line 84) | Tally(StringTable& table_) : table(table_) {}
  function CountOccurrences (line 96) | static void CountOccurrences(int nthreads) {
  type Sound (line 129) | struct Sound {
  function CountRateSum (line 196) | int CountRateSum(Sound sounds[], const int num, const int part) {
  function CreateData (line 216) | static void CreateData() {
  function main (line 239) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/examples/concurrent_priority_queue/shortpath/shortpath.cpp
  type point (line 40) | struct point {
    method point (line 42) | point() {}
    method point (line 43) | point(double _x, double _y) : x(_x), y(_y) {}
    method point (line 44) | point(const point& p) : x(p.x), y(p.y) {}
  function get_distance (line 47) | double get_distance(const point& p1, const point& p2) {
  function point (line 53) | point generate_random_point(utility::FastRandom& mr) {
    method point (line 42) | point() {}
    method point (line 43) | point(double _x, double _y) : x(_x), y(_y) {}
    method point (line 44) | point(const point& p) : x(p.x), y(p.y) {}
  function die_toss (line 61) | bool die_toss(std::size_t a, std::size_t b, utility::FastRandom& mr) {
  type compare_f (line 99) | struct compare_f {
  function shortpath (line 109) | void shortpath() {
  function shortpath_helper (line 122) | void shortpath_helper() {
  function make_path (line 168) | void make_path(vertex_id src, vertex_id dst, std::vector<vertex_id>& pat...
  function print_path (line 182) | void print_path() {
  function InitializeGraph (line 212) | void InitializeGraph() {
  function ReleaseGraph (line 259) | void ReleaseGraph() {
  function ResetGraph (line 263) | void ResetGraph() {
  function main (line 275) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/examples/getting_started/sub_string_finder/sub_string_finder.cpp
  class SubStringFinder (line 31) | class SubStringFinder {
    method SubStringFinder (line 58) | SubStringFinder(const std::string &s, std::vector<std::size_t> &m, std...
  function main (line 64) | int main(int argc, char *argv[]) {

FILE: third-party/tbb/examples/getting_started/sub_string_finder/sub_string_finder_extended.cpp
  function SerialSubStringFinder (line 28) | void SerialSubStringFinder(const std::string &str,
  class SubStringFinder (line 50) | class SubStringFinder {
    method SubStringFinder (line 78) | SubStringFinder(const char *s, const std::size_t s_len, std::size_t *m...
  function main (line 85) | int main() {

FILE: third-party/tbb/examples/getting_started/sub_string_finder/sub_string_finder_pretty.cpp
  class SubStringFinder (line 28) | class SubStringFinder {
    method SubStringFinder (line 55) | SubStringFinder(const std::string &s, std::vector<std::size_t> &m, std...
  function main (line 61) | int main() {

FILE: third-party/tbb/examples/graph/binpack/binpack.cpp
  class bin_filler (line 77) | class bin_filler {
    method bin_filler (line 90) | bin_filler(std::size_t bidx, value_pool* _q)
  class item_generator (line 202) | class item_generator {
    method item_generator (line 206) | item_generator() : counter(0) {}
    method value_type (line 207) | value_type operator()(oneapi::tbb::flow_control& fc) {
  class bin_printer (line 220) | class bin_printer {
    method bin_printer (line 227) | bin_printer()
  function main (line 265) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/examples/graph/cholesky/cholesky.cpp
  function collapse_tile_array (line 94) | static void collapse_tile_array(double ***tile, double *A, int n, int b) {
  class algorithm (line 120) | class algorithm {
    method check_if_valid (line 124) | bool check_if_valid(double *A0, double *C, double *A, int n) {
    method algorithm (line 163) | algorithm(const std::string &alg_name, bool t) : name(alg_name), is_ti...
  function call_dpotf2 (line 228) | static void call_dpotf2(double ***tile, int b, int k) {
  function call_dtrsm (line 236) | static void call_dtrsm(double ***tile, int b, int k, int j) {
  function call_dsyr2k (line 245) | static void call_dsyr2k(double ***tile, int b, int k, int j, int i) {
  class algorithm_crout (line 264) | class algorithm_crout : public algorithm {
    method algorithm_crout (line 266) | algorithm_crout() : algorithm("crout_cholesky", true) {}
    method func (line 269) | virtual void func(void *ptr, int n, int b) {
  class algorithm_dpotrf (line 287) | class algorithm_dpotrf : public algorithm {
    method algorithm_dpotrf (line 289) | algorithm_dpotrf() : algorithm("dpotrf_cholesky", false) {}
    method func (line 292) | virtual void func(void *ptr, int n, int /* b */) {
  class dpotf2_body (line 324) | class dpotf2_body {
    method dpotf2_body (line 329) | dpotf2_body(int p_, int b_) : p(p_), b(b_) {}
  class dtrsm_body (line 351) | class dtrsm_body {
    method dtrsm_body (line 356) | dtrsm_body(int p_, int b_) : p(p_), b(b_) {}
  class dsyr2k_body (line 388) | class dsyr2k_body {
    method dsyr2k_body (line 393) | dsyr2k_body(int p_, int b_) : p(p_), b(b_) {}
  type tagged_tile_to_size_t (line 458) | struct tagged_tile_to_size_t {
  class algorithm_join (line 464) | class algorithm_join : public algorithm {
    method algorithm_join (line 466) | algorithm_join() : algorithm("data_join_cholesky", true) {}
    method func (line 469) | virtual void func(void *ptr, int n, int b) {
  class algorithm_depend (line 540) | class algorithm_depend : public algorithm {
    method algorithm_depend (line 542) | algorithm_depend() : algorithm("depend_cholesky", true) {}
    method func (line 545) | virtual void func(void *ptr, int n, int b) {
  function process_args (line 619) | bool process_args(int argc, char *argv[]) {
  function main (line 672) | int main(int argc, char *argv[]) {

FILE: third-party/tbb/examples/graph/cholesky/init.cpp
  function posdef_gen (line 24) | static void posdef_gen(double *A, int n) {
  function matrix_init (line 58) | void matrix_init(double *&A, int &n, const char *fname) {
  function matrix_write (line 94) | void matrix_write(double *A, int n, const char *fname, bool is_triangula...

FILE: third-party/tbb/examples/graph/dining_philosophers/dining_philosophers.cpp
  type RunOptions (line 68) | struct RunOptions {
    method RunOptions (line 72) | RunOptions(utility::thread_number_range threads_, int number_of_philos...
  function RunOptions (line 78) | RunOptions ParseCommandLine(int argc, char *argv[]) {
    method RunOptions (line 72) | RunOptions(utility::thread_number_range threads_, int number_of_philos...
  class chopstick (line 105) | class chopstick {}
  class philosopher (line 118) | class philosopher {
    method philosopher (line 120) | philosopher(const char *name) : my_name(name), my_count(num_times) {}
  class think_node_body (line 152) | class think_node_body {
    method think_node_body (line 156) | think_node_body(philosopher &p) : my_philosopher(p) {}
    method think_node_body (line 157) | think_node_body(const think_node_body &other) : my_philosopher(other.m...
  class eat_node_body (line 164) | class eat_node_body {
    method eat_node_body (line 168) | eat_node_body(philosopher &p) : my_philosopher(p) {}
    method eat_node_body (line 169) | eat_node_body(const eat_node_body &other) : my_philosopher(other.my_ph...
  class forward_node_body (line 176) | class forward_node_body {
    method forward_node_body (line 180) | forward_node_body(philosopher &p) : my_philosopher(p) {}
    method forward_node_body (line 181) | forward_node_body(const forward_node_body &other) : my_philosopher(oth...
  function main (line 240) | int main(int argc, char *argv[]) {

FILE: third-party/tbb/examples/graph/fgbzip2/blocksort.cpp
  function fallbackSimpleSort (line 77) | static __inline__ void fallbackSimpleSort(UInt32* fmap, UInt32* eclass, ...
  function fallbackQSort3 (line 143) | static void fallbackQSort3(UInt32* fmap, UInt32* eclass, Int32 loSt, Int...
  function fallbackSort (line 271) | static void fallbackSort(UInt32* fmap, UInt32* eclass, UInt32* bhtab, In...
  function Bool (line 418) | static __inline__ Bool mainGtU(UInt32 i1,
  function mainSimpleSort (line 628) | static void mainSimpleSort(UInt32* ptr,
  function UChar (line 730) | static __inline__ UChar mmed3(UChar a, UChar b, UChar c) {
  function mainQSort3 (line 783) | static void mainQSort3(UInt32* ptr,
  function mainSort (line 928) | static void mainSort(UInt32* ptr,
  function BZ2_blockSort (line 1218) | void BZ2_blockSort(EState* s) {

FILE: third-party/tbb/examples/graph/fgbzip2/bzlib.cpp
  function BZ2_bz__AssertH__fail (line 87) | void BZ2_bz__AssertH__fail(int errcode) {
  function bz_config_ok (line 132) | static int bz_config_ok(void) {
  function default_bzfree (line 148) | static void default_bzfree(void* opaque, void* addr) {
  function prepare_new_block (line 154) | static void prepare_new_block(EState* s) {
  function init_RL (line 166) | static void init_RL(EState* s) {
  function Bool (line 171) | static Bool isempty_RL(EState* s) {
  function add_pair_to_block (line 248) | static void add_pair_to_block(EState* s) {
  function flush_RL (line 291) | static void flush_RL(EState* s) {
  function Bool (line 323) | static Bool copy_input_until_stop(EState* s) {
  function Bool (line 370) | static Bool copy_output_until_stop(EState* s) {
  function Bool (line 396) | static Bool handle_compress(bz_stream* strm) {
  function Bool (line 569) | static Bool unRLE_obuf_to_output_FAST(DState* s) {
  function Int32 (line 757) | Int32 BZ2_indexIntoF(Int32 indx, Int32* cftab) {
  function Bool (line 775) | static Bool unRLE_obuf_to_output_SMALL(DState* s) {
  function Bool (line 1026) | static Bool myfeof(FILE* f) {
  function BZFILE (line 1035) | BZFILE* BZ_API(
  function BZFILE (line 1222) | BZFILE* BZ_API(
  function BZFILE (line 1522) | static BZFILE* bzopen_or_bzdopen(const char* path, /* no use when bzdope...
  function BZFILE (line 1600) | BZFILE* BZ_API(BZ2_bzopen)(const char* path, const char* mode) {
  function BZFILE (line 1605) | BZFILE* BZ_API(BZ2_bzdopen)(int fd, const char* mode) {

FILE: third-party/tbb/examples/graph/fgbzip2/compress.cpp
  function BZ2_bsInitWrite (line 83) | void BZ2_bsInitWrite(EState* s) {
  function bsFinishWrite (line 89) | static void bsFinishWrite(EState* s) {
  function bsW (line 110) | static __inline__ void bsW(EState* s, Int32 n, UInt32 v) {
  function bsPutUInt32 (line 117) | static void bsPutUInt32(EState* s, UInt32 u) {
  function bsPutUChar (line 125) | static void bsPutUChar(EState* s, UChar c) {
  function makeMaps_e (line 134) | static void makeMaps_e(EState* s) {
  function generateMTFValues (line 145) | static void generateMTFValues(EState* s) {
  function sendMTFValues (line 276) | static void sendMTFValues(EState* s) {
  function BZ2_compressBlock (line 780) | void BZ2_compressBlock(EState* s, Bool is_last_block) {

FILE: third-party/tbb/examples/graph/fgbzip2/decompress.cpp
  function makeMaps_d (line 72) | static void makeMaps_d(DState* s) {
  function Int32 (line 147) | Int32 BZ2_decompress(DState* s) {

FILE: third-party/tbb/examples/graph/fgbzip2/fgbzip2.cpp
  type Buffer (line 33) | struct Buffer {
  type BufferMsg (line 38) | struct BufferMsg {
    method BufferMsg (line 39) | BufferMsg() {}
    method BufferMsg (line 40) | BufferMsg(Buffer& inputBuffer, Buffer& outputBuffer, std::size_t seqId...
    method BufferMsg (line 46) | static BufferMsg createBufferMsg(std::size_t seqId, std::size_t chunkS...
    method destroyBufferMsg (line 59) | static void destroyBufferMsg(const BufferMsg& destroyMsg) {
    method markLast (line 64) | void markLast(std::size_t lastId) {
  class BufferCompressor (line 75) | class BufferCompressor {
    method BufferCompressor (line 77) | BufferCompressor(int blockSizeIn100KB) : m_blockSize(blockSizeIn100KB) {}
    method BufferMsg (line 79) | BufferMsg operator()(BufferMsg buffer) const {
  class IOOperations (line 98) | class IOOperations {
    method IOOperations (line 100) | IOOperations(std::ifstream& inputStream, std::ofstream& outputStream, ...
    method readChunk (line 106) | void readChunk(Buffer& buffer) {
    method writeChunk (line 112) | void writeChunk(const Buffer& buffer) {
    method chunksRead (line 116) | std::size_t chunksRead() const {
    method chunkSize (line 120) | std::size_t chunkSize() const {
    method hasDataToRead (line 124) | bool hasDataToRead() const {
  class AsyncNodeActivity (line 145) | class AsyncNodeActivity {
    method AsyncNodeActivity (line 147) | AsyncNodeActivity(IOOperations& io)
    method submitRead (line 156) | void submitRead(async_file_reader_node::gateway_type& gateway) {
    method submitWrite (line 162) | void submitWrite(const BufferMsg& bufferMsg) {
    method readingLoop (line 167) | void readingLoop(async_file_reader_node::gateway_type& gateway) {
    method writingLoop (line 177) | void writingLoop() {
    method sendLastMessage (line 186) | void sendLastMessage(async_file_reader_node::gateway_type& gateway) {
  function fgCompressionAsyncNode (line 200) | void fgCompressionAsyncNode(IOOperations& io, int blockSizeIn100KB) {
  function fgCompression (line 243) | void fgCompression(IOOperations& io, int blockSizeIn100KB) {
  function endsWith (line 280) | bool endsWith(const std::string& str, const std::string& suffix) {
  function main (line 286) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/examples/graph/fgbzip2/huffman.cpp
  function BZ2_hbMakeCodeLengths (line 111) | void BZ2_hbMakeCodeLengths(UChar *len, Int32 *freq, Int32 alphaSize, Int...
  function BZ2_hbAssignCodes (line 205) | void BZ2_hbAssignCodes(Int32 *code, UChar *length, Int32 minLen, Int32 m...
  function BZ2_hbCreateDecodeTables (line 220) | void BZ2_hbCreateDecodeTables(Int32 *limit,

FILE: third-party/tbb/examples/graph/logic_sim/D_latch.hpp
  class D_latch (line 22) | class D_latch : public oneapi::tbb::flow::composite_node<std::tuple<sign...
    method D_latch (line 37) | D_latch(oneapi::tbb::flow::graph& g)

FILE: third-party/tbb/examples/graph/logic_sim/basics.hpp
  function rt_sleep (line 33) | void rt_sleep(int msec) {
  function rt_sleep (line 44) | void rt_sleep(int msec) {
  class gate (line 57) | class gate
  class gate<1> (line 60) | class gate<1>
    method gate (line 71) | gate(oneapi::tbb::flow::graph& g, Body b)
    method gate (line 83) | gate& operator=(const gate& src) {
  class gate<2> (line 96) | class gate<2> : public oneapi::tbb::flow::composite_node<std::tuple<sign...
    method gate (line 108) | gate(oneapi::tbb::flow::graph& g, Body b)
    method gate (line 120) | gate& operator=(const gate& src) {
  class gate<3> (line 133) | class gate<3> : public oneapi::tbb::flow::composite_node<std::tuple<sign...
    method gate (line 146) | gate(oneapi::tbb::flow::graph& g, Body b)
    method gate (line 159) | gate& operator=(const gate& src) {
  class gate<4> (line 172) | class gate<4> : public oneapi::tbb::flow::composite_node<
    method gate (line 186) | gate(oneapi::tbb::flow::graph& g, Body b)
    method gate (line 201) | gate& operator=(const gate& src) {
  class steady_signal (line 214) | class steady_signal {
    method steady_signal (line 220) | steady_signal(oneapi::tbb::flow::graph& g, signal_t v)
    method steady_signal (line 224) | steady_signal(const steady_signal& src)
    method steady_signal (line 230) | steady_signal& operator=(const steady_signal& src) {
    method activate (line 236) | void activate() {
  class pulse (line 241) | class pulse {
    class clock_body (line 242) | class clock_body {
      method clock_body (line 248) | clock_body(std::size_t& _ms, int& _reps) : ms(_ms), reps(_reps), val...
      method signal_t (line 249) | signal_t operator()(oneapi::tbb::flow_control& fc) {
    method pulse (line 270) | pulse(oneapi::tbb::flow::graph& g, std::size_t _ms = 1000, int _reps =...
    method pulse (line 277) | pulse(const pulse& src)
    method pulse (line 286) | pulse& operator=(const pulse& src) {
    method activate (line 296) | void activate() {
    method reset (line 299) | void reset() {
  class push_button (line 304) | class push_button {
    method push_button (line 309) | push_button(oneapi::tbb::flow::graph& g) : my_graph(g), push_button_no...
    method push_button (line 312) | push_button(const push_button& src) : my_graph(src.my_graph), push_but...
    method push_button (line 317) | push_button& operator=(const push_button& src) {
    method press (line 323) | void press() {
    method release (line 326) | void release() {
  class toggle (line 331) | class toggle {
    method toggle (line 337) | toggle(oneapi::tbb::flow::graph& g) : my_graph(g), state(undefined), t...
    method toggle (line 338) | toggle(const toggle& src)
    method toggle (line 344) | toggle& operator=(const toggle& src) {
    method flip (line 350) | void flip() {
    method activate (line 357) | void activate() {
  class buffer (line 364) | class buffer : public gate<1> {
    class buffer_body (line 367) | class buffer_body {
      method buffer_body (line 372) | buffer_body() : state(undefined), touched(false) {}
    method buffer (line 383) | buffer(oneapi::tbb::flow::graph& g) : gate<1>(g, buffer_body()) {}
    method buffer (line 384) | buffer(const buffer& src) : gate<1>(src.my_graph, buffer_body()) {}
  class not_gate (line 388) | class not_gate : public gate<1> {
    class not_body (line 391) | class not_body {
      method not_body (line 396) | not_body() : port(undefined), touched(false) {}
    method not_gate (line 410) | not_gate(oneapi::tbb::flow::graph& g) : gate<1>(g, not_body()) {}
    method not_gate (line 411) | not_gate(const not_gate& src) : gate<1>(src.my_graph, not_body()) {}
  class and_gate (line 416) | class and_gate : public gate<N> {
    class and_body (line 420) | class and_body {
      method and_body (line 426) | and_body() : state(undefined), touched(false) {
    method and_gate (line 454) | and_gate(oneapi::tbb::flow::graph& g) : gate<N>(g, and_body()) {}
    method and_gate (line 455) | and_gate(const and_gate<N>& src) : gate<N>(src.my_graph, and_body()) {}
  class or_gate (line 460) | class or_gate : public gate<N> {
    class or_body (line 464) | class or_body {
      method or_body (line 470) | or_body() : state(undefined), touched(false) {
    method or_gate (line 498) | or_gate(oneapi::tbb::flow::graph& g) : gate<N>(g, or_body()) {}
    method or_gate (line 499) | or_gate(const or_gate& src) : gate<N>(src.my_graph, or_body()) {}
  class xor_gate (line 504) | class xor_gate : public gate<N> {
    class xor_body (line 508) | class xor_body {
      method xor_body (line 514) | xor_body() : state(undefined), touched(false) {
    method xor_gate (line 549) | xor_gate(oneapi::tbb::flow::graph& g) : gate<N>(g, xor_body()) {}
    method xor_gate (line 550) | xor_gate(const xor_gate& src) : gate<N>(src.my_graph, xor_body()) {}
  class nor_gate (line 555) | class nor_gate : public gate<N> {
    class nor_body (line 559) | class nor_body {
      method nor_body (line 565) | nor_body() : state(undefined), touched(false) {
    method nor_gate (line 597) | nor_gate(oneapi::tbb::flow::graph& g) : gate<N>(g, nor_body()) {}
    method nor_gate (line 598) | nor_gate(const nor_gate& src) : gate<N>(src.my_graph, nor_body()) {}
  class led (line 603) | class led {
    class led_body (line 604) | class led_body {
      method led_body (line 611) | led_body(signal_t& s, std::string& l, bool r)
    method led (line 637) | led(oneapi::tbb::flow::graph& g, std::string l, bool rc = false)
    method led (line 643) | led(const led& src)
    method led (line 652) | led& operator=(const led& src) {
    method display (line 661) | void display() {
    method signal_t (line 669) | signal_t get_value() {
  class digit (line 674) | class digit : public gate<4> {
    class digit_body (line 678) | class digit_body {
      method digit_body (line 686) | digit_body(unsigned int& s, std::string& l, bool& r)
    method digit (line 717) | digit(oneapi::tbb::flow::graph& g, std::string l, bool rc = false)
    method digit (line 722) | digit(const digit& src)
    method digit (line 730) | digit& operator=(const digit& src) {
    method display (line 736) | void display() {
    method get_value (line 739) | unsigned int get_value() {

FILE: third-party/tbb/examples/graph/logic_sim/four_bit_adder.hpp
  class four_bit_adder (line 35) | class four_bit_adder : public fba_base_type {
    method four_bit_adder (line 40) | four_bit_adder(oneapi::tbb::flow::graph& g)
    method four_bit_adder (line 47) | four_bit_adder(const four_bit_adder& src)
    method make_connections (line 57) | void make_connections() {
    method set_up_composite (line 62) | void set_up_composite() {

FILE: third-party/tbb/examples/graph/logic_sim/one_bit_adder.hpp
  type P (line 20) | namespace P {
  class one_bit_adder (line 47) | class one_bit_adder
    method one_bit_adder (line 64) | one_bit_adder(oneapi::tbb::flow::graph& g)
    method one_bit_adder (line 78) | one_bit_adder(const one_bit_adder& src)
    method make_connections (line 96) | void make_connections() {
    method set_up_composite (line 109) | void set_up_composite() {

FILE: third-party/tbb/examples/graph/logic_sim/test_all.cpp
  function main (line 45) | int main(int argc, char *argv[]) {

FILE: third-party/tbb/examples/graph/logic_sim/two_bit_adder.hpp
  class two_bit_adder (line 22) | class two_bit_adder : public oneapi::tbb::flow::composite_node<
    method two_bit_adder (line 33) | two_bit_adder(oneapi::tbb::flow::graph& g)
    method two_bit_adder (line 40) | two_bit_adder(const two_bit_adder& src)
    method make_connections (line 50) | void make_connections() {
    method set_up_composite (line 53) | void set_up_composite() {

FILE: third-party/tbb/examples/graph/som/som.cpp
  function remark_SOM_element (line 48) | void remark_SOM_element(const SOM_element &s) {
  function remark_search_result_type (line 69) | void remark_search_result_type(const search_result_type &s) {
  function randval (line 73) | double randval(double lowlimit, double highlimit) {
  function find_data_ranges (line 77) | void find_data_ranges(teaching_vector_type &teaching,
  function add_fraction_of_difference (line 89) | void add_fraction_of_difference(SOM_element &to, SOM_element const &from...
  function distance_squared (line 95) | double distance_squared(SOM_element x, SOM_element y) {
  function readInputData (line 212) | void readInputData() {

FILE: third-party/tbb/examples/graph/som/som.hpp
  type InitializeType (line 67) | enum InitializeType { InitializeRandom, InitializeGradient }
  class SOM_element (line 71) | class SOM_element
    method SOM_element (line 82) | SOM_element() : w(nElements, 0.0) {}
    method elementwise_max (line 100) | void elementwise_max(SOM_element const &other) {
    method elementwise_min (line 105) | void elementwise_min(SOM_element const &other) {
    method size (line 110) | std::size_t size() const {
  class SOM_element (line 76) | class SOM_element {
    method SOM_element (line 82) | SOM_element() : w(nElements, 0.0) {}
    method elementwise_max (line 100) | void elementwise_max(SOM_element const &other) {
    method elementwise_min (line 105) | void elementwise_min(SOM_element const &other) {
    method size (line 110) | std::size_t size() const {
  class SOMap (line 130) | class SOMap {
    method SOMap (line 134) | SOMap(int xSize, int ySize) {
    method size (line 144) | std::size_t size() {
    method teaching_vector_type (line 148) | teaching_vector_type &operator[](int indx) {
    method SOM_element (line 151) | SOM_element &at(int xVal, int yVal) {
    method SOM_element (line 154) | SOM_element &at(search_result_type const &s) {
    method epoch_update (line 157) | void epoch_update(SOM_element const &s,
    method BMU (line 183) | double BMU(const SOM_element &s, int &xval, int &yval) {

FILE: third-party/tbb/examples/graph/som/som_graph.cpp
  class BMU_search_body (line 83) | class BMU_search_body {
    method BMU_search_body (line 89) | BMU_search_body(SOMap &_m, subsquare_type &_sq, int &fnt)
    method BMU_search_body (line 93) | BMU_search_body(const BMU_search_body &other)
    method search_result_type (line 97) | search_result_type operator()(const SOM_element s) {
  function build_BMU_graph (line 136) | void build_BMU_graph(SOMap &map1, oneapi::tbb::task_arena &ta) {
  function wait_for_all_graphs (line 189) | void wait_for_all_graphs(int cIndex) { // cIndex ranges over [0 .. SPECU...
  function destroy_BMU_graph (line 197) | void destroy_BMU_graph() {
  function find_subrange_overlap (line 215) | void find_subrange_overlap(int const &xval,
  function overlap (line 247) | bool overlap(int &xval, int &yval, search_result_type &sr) {
  function cancel_submaps (line 254) | void cancel_submaps(int &xval, int &yval, double &radius, int indx) {
  function restart_submaps (line 270) | void restart_submaps(int &xval, int &yval, double &radius, int indx, SOM...
  function search_result_type (line 286) | search_result_type graph_BMU(int indx) { // indx ranges over [0 .. SPECU...
  function graph_teach (line 367) | void graph_teach(SOMap &map1, teaching_vector_type &in, oneapi::tbb::tas...
  function main (line 439) | int main(int argc, char *argv[]) {

FILE: third-party/tbb/examples/migration/recursive_fibonacci/fibonacci.cpp
  function measure (line 28) | std::pair</* result */ unsigned long, /* time */ unsigned long> measure(...
  function main (line 48) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/examples/migration/recursive_fibonacci/fibonacci_single_task.h
  function serial_fib_1 (line 29) | long serial_fib_1(int n) {
  type single_fib_task (line 33) | struct single_fib_task
  function state (line 34) | enum class state {
  function x_l (line 86) | int x_l{ 0 }, x_r{ 0 };
  function fibonacci_single_task (line 90) | int fibonacci_single_task(int n) {

FILE: third-party/tbb/examples/migration/recursive_fibonacci/fibonacci_two_tasks.h
  function serial_fib (line 29) | long serial_fib(int n) {
  function base_task (line 33) | struct fib_continuation : task_emulation::base_task {
  function fibonacci_two_tasks (line 71) | int fibonacci_two_tasks(int n) {

FILE: third-party/tbb/examples/migration/recursive_fibonacci/task_emulation_layer.h
  function namespace (line 25) | namespace task_emulation {
  function class (line 46) | class base_task {
  function recycle_as_continuation (line 122) | void recycle_as_continuation() {
  function add_child_reference (line 126) | void add_child_reference() {
  type class (line 135) | enum class
  function F (line 152) | F obj{std::forward<Args>(args)...};
  function base_task (line 172) | base_task* m_parent{nullptr};

FILE: third-party/tbb/examples/parallel_for/game_of_life/Board.hpp
  type Matrix (line 23) | struct Matrix {
  class Board (line 29) | class Board {

FILE: third-party/tbb/examples/parallel_for/game_of_life/Evolution.cpp
  class tbb_parallel_task (line 140) | class tbb_parallel_task {
    method set_values (line 142) | static void set_values(Matrix* source, char* dest) {
    method tbb_parallel_task (line 154) | tbb_parallel_task() {}

FILE: third-party/tbb/examples/parallel_for/game_of_life/Evolution.hpp
  class Evolution (line 43) | class Evolution {
    method Evolution (line 45) | Evolution(Matrix* m, //! beginning matrix including initial pattern
    method Quit (line 65) | virtual void Quit() {
    method SetPause (line 73) | virtual void SetPause(bool condition) {
  class SequentialEvolution (line 107) | class SequentialEvolution : public Evolution {
    method SequentialEvolution (line 109) | SequentialEvolution(Matrix* m, BoardPtr board) : Evolution(m, board) {}
  class ParallelEvolution (line 118) | class ParallelEvolution : public Evolution {
    method ParallelEvolution (line 120) | ParallelEvolution(Matrix* m, BoardPtr board) : Evolution(m, board), m_...

FILE: third-party/tbb/examples/parallel_for/game_of_life/Game_of_life.cpp
  function PrintUsage (line 70) | void PrintUsage() {
  function ParseCommandLine (line 81) | bool ParseCommandLine(int argc, char* argv[]) {
  function main (line 115) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/examples/parallel_for/game_of_life/Update_state.cpp
  function create_record (line 25) | inline void create_record(char* src, unsigned* dst, unsigned width) {
  function sum_offset (line 35) | inline void sum_offset(__m128i* X,
  function shift_left2D (line 49) | inline void shift_left2D(__m128i* X, unsigned height, unsigned size_sse_...
  function shift_right2D (line 72) | inline void shift_right2D(__m128i* X, unsigned height, unsigned size_sse...
  function UpdateState (line 97) | void UpdateState(Matrix* m_matrix, char* dest, int begin, int end) {
  function GetAdjacentCellState (line 218) | char GetAdjacentCellState(char* source, // pointer to source data block
  function CheckCell (line 331) | char CheckCell(Matrix* m_matrix, int cellNumber) {
  function UpdateState (line 361) | void UpdateState(Matrix* m_matrix, char* dest, int begin, int end) {

FILE: third-party/tbb/examples/parallel_for/polygon_overlay/polymain.cpp
  function main (line 44) | int main(int argc, char *argv[]) {
  function Usage (line 110) | void Usage(int argc, char *argv[]) {
  function ParseCmdLine (line 148) | bool ParseCmdLine(int argc, char *argv[]) {
  function GenerateMap (line 349) | bool GenerateMap(Polygon_map_t **newMap,
  function CheckPolygonMap (line 544) | void CheckPolygonMap(Polygon_map_t *checkMap) {
  function CompOnePolygon (line 631) | bool CompOnePolygon(RPolygon &p1, RPolygon &p2) {
  function PolygonsEqual (line 643) | bool PolygonsEqual(RPolygon *p1, RPolygon *p2) {
  function ComparePolygonMaps (line 651) | bool ComparePolygonMaps(Polygon_map_t *map1, Polygon_map_t *map2) {
  function SetRandomSeed (line 687) | void SetRandomSeed(int newSeed) {
  function NextRan (line 691) | int NextRan(int n) {

FILE: third-party/tbb/examples/parallel_for/polygon_overlay/polyover.cpp
  function OverlayOnePolygonWithMap (line 47) | void OverlayOnePolygonWithMap(Polygon_map_t *resultMap,
  function SerialOverlayMaps (line 84) | void SerialOverlayMaps(Polygon_map_t **resultMap, Polygon_map_t *map1, P...
  class ApplyOverlay (line 105) | class ApplyOverlay {
    method ApplyOverlay (line 121) | ApplyOverlay(Polygon_map_t *resultMap,
  function NaiveParallelOverlay (line 137) | void NaiveParallelOverlay(Polygon_map_t *&result_map,
  function split_at (line 200) | void split_at(Flagged_map_t &in_map,
  class blocked_range_with_maps (line 227) | class blocked_range_with_maps {
    method blocked_range_with_maps (line 236) | blocked_range_with_maps(T begin,
    method blocked_range_with_maps (line 254) | blocked_range_with_maps(const blocked_range_with_maps &other)
    method empty (line 258) | bool empty() const {
    method is_divisible (line 261) | bool is_divisible() const {
    method check_my_map (line 266) | void check_my_map() {
    method dump_map (line 280) | void dump_map(Flagged_map_t &mapx) {
    method blocked_range_with_maps (line 293) | blocked_range_with_maps(blocked_range_with_maps &lhs_r, oneapi::tbb::s...
    method my_range_type (line 308) | const my_range_type &range() const {
    method Flagged_map_t (line 311) | Flagged_map_t &map1() {
    method Flagged_map_t (line 314) | Flagged_map_t &map2() {
  class ApplySplitOverlay (line 323) | class ApplySplitOverlay {
    method ApplySplitOverlay (line 384) | ApplySplitOverlay(Polygon_map_t *resultMap,
  function SplitParallelOverlay (line 401) | void SplitParallelOverlay(Polygon_map_t **result_map,
  class ApplySplitOverlayCV (line 466) | class ApplySplitOverlayCV {
    method ApplySplitOverlayCV (line 515) | ApplySplitOverlayCV(concurrent_Polygon_map_t *resultMap,
  function SplitParallelOverlayCV (line 530) | void SplitParallelOverlayCV(concurrent_Polygon_map_t **result_map,
  class ApplySplitOverlayETS (line 603) | class ApplySplitOverlayETS {
    method ApplySplitOverlayETS (line 652) | ApplySplitOverlayETS(ETS_Polygon_map_t *resultMap, Polygon_map_t *map1...
  function SplitParallelOverlayETS (line 665) | void SplitParallelOverlayETS(ETS_Polygon_map_t **result_map,

FILE: third-party/tbb/examples/parallel_for/polygon_overlay/pover_video.cpp
  function rt_sleep (line 33) | void rt_sleep(int msec) {
  function rt_sleep (line 44) | void rt_sleep(int msec) {
  function g_next_frame (line 50) | bool g_next_frame() {
  function g_last_frame (line 58) | bool g_last_frame() {
  function initializeVideo (line 64) | bool initializeVideo(int argc, char *argv[]) {

FILE: third-party/tbb/examples/parallel_for/polygon_overlay/pover_video.hpp
  class pover_video (line 32) | class pover_video : public video {
    method graphic_display (line 37) | bool graphic_display() {
    method graphic_display (line 41) | bool graphic_display() {

FILE: third-party/tbb/examples/parallel_for/polygon_overlay/rpolygon.hpp
  class RPolygon (line 31) | class RPolygon
    method RPolygon (line 41) | RPolygon() {
    method RPolygon (line 45) | RPolygon(int xMin, int yMin, int xMax, int yMax, int r = -1, int g = -...
    method set_nodraw (line 59) | void set_nodraw(int xMin, int yMin, int xMax, int yMax) {
    method set (line 67) | void set(int xMin, int yMin, int xMax, int yMax) {
    method get (line 73) | void get(int *xMin, int *yMin, int *xMax, int *yMax) const {
    method xmax (line 79) | int xmax() const {
    method xmin (line 82) | int xmin() const {
    method ymax (line 85) | int ymax() const {
    method ymin (line 88) | int ymin() const {
    method setColor (line 91) | void setColor(colorcomp_t newr, colorcomp_t newg, colorcomp_t newb) {
    method getColor (line 96) | void getColor(int *myr, int *myg, int *myb) {
    method color_t (line 101) | color_t myColor() {
    method drawPoly (line 104) | void drawPoly() {
    method area (line 122) | int area() {
    method print (line 125) | void print(int i) {
  type MallocBehavior (line 35) | enum MallocBehavior { UseMalloc, UseScalableAllocator }
  class RPolygon (line 39) | class RPolygon {
    method RPolygon (line 41) | RPolygon() {
    method RPolygon (line 45) | RPolygon(int xMin, int yMin, int xMax, int yMax, int r = -1, int g = -...
    method set_nodraw (line 59) | void set_nodraw(int xMin, int yMin, int xMax, int yMax) {
    method set (line 67) | void set(int xMin, int yMin, int xMax, int yMax) {
    method get (line 73) | void get(int *xMin, int *yMin, int *xMax, int *yMax) const {
    method xmax (line 79) | int xmax() const {
    method xmin (line 82) | int xmin() const {
    method ymax (line 85) | int ymax() const {
    method ymin (line 88) | int ymin() const {
    method setColor (line 91) | void setColor(colorcomp_t newr, colorcomp_t newg, colorcomp_t newb) {
    method getColor (line 96) | void getColor(int *myr, int *myg, int *myb) {
    method color_t (line 101) | color_t myColor() {
    method drawPoly (line 104) | void drawPoly() {
    method area (line 122) | int area() {
    method print (line 125) | void print(int i) {
  class RPolygon_flagged (line 156) | class RPolygon_flagged {
    method RPolygon_flagged (line 161) | RPolygon_flagged() {
    method RPolygon_flagged (line 165) | RPolygon_flagged(RPolygon *_p, bool _is_duplicate) : myPoly(_p), is_du...
    method isDuplicate (line 166) | bool isDuplicate() {
    method setDuplicate (line 169) | void setDuplicate(bool newValue) {
    method RPolygon (line 172) | RPolygon *p() {
    method setp (line 175) | void setp(RPolygon *newp) {
  class std::vector<RPolygon, RPolygon_allocator> (line 180) | class std::vector<RPolygon, RPolygon_allocator>
  class oneapi::tbb::concurrent_vector<RPolygon, RPolygon_allocator> (line 181) | class oneapi::tbb::concurrent_vector<RPolygon, RPolygon_allocator>
  class oneapi::tbb::enumerable_thread_specific<Polygon_map_t> (line 182) | class oneapi::tbb::enumerable_thread_specific<Polygon_map_t>
  class std::vector<RPolygon_flagged, oneapi::tbb::tbb_allocator<RPolygon_flagged>> (line 183) | class std::vector<RPolygon_flagged, oneapi::tbb::tbb_allocator<RPolygon_...
  function PolygonsOverlap (line 186) | inline bool PolygonsOverlap(RPolygon *p1, RPolygon *p2, int &xl, int &yl...

FILE: third-party/tbb/examples/parallel_for/seismic/main.cpp
  type RunOptions (line 32) | struct RunOptions {
    method RunOptions (line 41) | RunOptions(utility::thread_number_range threads_,
  function RunOptions (line 53) | RunOptions ParseCommandLine(int argc, char *argv[]) {
    method RunOptions (line 41) | RunOptions(utility::thread_number_range threads_,
  function main (line 80) | int main(int argc, char *argv[]) {

FILE: third-party/tbb/examples/parallel_for/seismic/seismic_video.cpp
  function LRESULT (line 101) | LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lP...
  function LRESULT (line 114) | LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM ...

FILE: third-party/tbb/examples/parallel_for/seismic/seismic_video.hpp
  class Universe (line 22) | class Universe
  class SeismicVideo (line 24) | class SeismicVideo : public video {

FILE: third-party/tbb/examples/parallel_for/seismic/universe.cpp
  type Universe::Rectangle (line 116) | struct Universe::Rectangle {
    type std::pair<int, int> (line 117) | struct std::pair<int, int>
    type std::pair<int, int> (line 118) | struct std::pair<int, int>
    method Rectangle (line 119) | Rectangle(int startX, int startY, int width, int height)
    method StartX (line 122) | int StartX() const {
    method StartY (line 125) | int StartY() const {
    method Width (line 128) | int Width() const {
    method Height (line 131) | int Height() const {
    method EndX (line 134) | int EndX() const {
    method EndY (line 137) | int EndY() const {
  type UpdateStressBody (line 166) | struct UpdateStressBody {
    method UpdateStressBody (line 168) | UpdateStressBody(Universe& u) : u_(u) {}
  type UpdateVelocityBody (line 194) | struct UpdateVelocityBody {
    method UpdateVelocityBody (line 196) | UpdateVelocityBody(Universe& u) : u_(u) {}

FILE: third-party/tbb/examples/parallel_for/seismic/universe.hpp
  class Universe (line 31) | class Universe {
    type MaterialType (line 68) | enum MaterialType { WATER = 0, SANDSTONE = 1, SHALE = 2 }
    type Rectangle (line 92) | struct Rectangle

FILE: third-party/tbb/examples/parallel_for/tachyon/src/api.cpp
  function vector (line 81) | vector rt_vector(apiflt x, apiflt y, apiflt z) {
  function color (line 91) | color rt_color(apiflt r, apiflt g, apiflt b) {
  function rt_initialize (line 101) | void rt_initialize() {
  function rt_renderscene (line 115) | void rt_renderscene(SceneHandle voidscene) {
  function rt_camerasetup (line 120) | void rt_camerasetup(SceneHandle voidscene,
  function rt_outputfile (line 153) | void rt_outputfile(SceneHandle voidscene, const char *outname) {
  function rt_resolution (line 158) | void rt_resolution(SceneHandle voidscene, int hres, int vres) {
  function rt_verbose (line 164) | void rt_verbose(SceneHandle voidscene, int v) {
  function rt_rawimage (line 169) | void rt_rawimage(SceneHandle voidscene, unsigned char *rawimage) {
  function rt_background (line 174) | void rt_background(SceneHandle voidscene, color col) {
  function rt_boundmode (line 181) | void rt_boundmode(SceneHandle voidscene, int mode) {
  function rt_boundthresh (line 186) | void rt_boundthresh(SceneHandle voidscene, int threshold) {
  function rt_displaymode (line 199) | void rt_displaymode(SceneHandle voidscene, int mode) {
  function rt_scenesetup (line 204) | void rt_scenesetup(SceneHandle voidscene, char *outname, int hres, int v...
  function SceneHandle (line 210) | SceneHandle rt_newscene(void) {
  function rt_deletescene (line 238) | void rt_deletescene(SceneHandle scene) {
  function apitextotex (line 243) | void apitextotex(apitexture *apitex, texture *tex) {
  function rt_tex_color (line 303) | void rt_tex_color(void *voidtex, color col) {
  function rt_tex_phong (line 308) | void rt_tex_phong(void *voidtex, apiflt phong, apiflt phongexp, int type) {
  function rt_light (line 315) | void rt_light(void *tex, vector ctr, apiflt rad) {
  function rt_scalarvol (line 330) | void rt_scalarvol(void *tex,
  function rt_extvol (line 342) | void rt_extvol(void *tex, vector min, vector max, int samples, flt (*eva...
  function rt_box (line 346) | void rt_box(void *tex, vector min, vector max) {
  function rt_cylinder (line 350) | void rt_cylinder(void *tex, vector ctr, vector axis, apiflt rad) {
  function rt_fcylinder (line 354) | void rt_fcylinder(void *tex, vector ctr, vector axis, apiflt rad) {
  function rt_plane (line 358) | void rt_plane(void *tex, vector ctr, vector norm) {
  function rt_ring (line 362) | void rt_ring(void *tex, vector ctr, vector norm, apiflt a, apiflt b) {
  function rt_sphere (line 366) | void rt_sphere(void *tex, vector ctr, apiflt rad) {
  function rt_tri (line 370) | void rt_tri(void *tex, vector v0, vector v1, vector v2) {
  function rt_stri (line 380) | void rt_stri(void *tex, vector v0, vector v1, vector v2, vector n0, vect...
  function rt_quadsphere (line 390) | void rt_quadsphere(void *tex, vector ctr, apiflt rad) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/apigeom.cpp
  function rt_polycylinder (line 59) | void rt_polycylinder(void *tex, vector *points, int numpts, apiflt rad) {
  function rt_heightfield (line 83) | void rt_heightfield(void *tex, vector ctr, int m, int n, apiflt *field, ...
  function rt_sheightfield (line 125) | static void
  function adjust (line 197) | static void adjust(apiflt *base,
  function subdivide (line 224) | static void
  function rt_landscape (line 252) | void rt_landscape(void *tex, int m, int n, vector ctr, apiflt wx, apiflt...

FILE: third-party/tbb/examples/parallel_for/tachyon/src/apitrigeom.cpp
  function rt_tri_fcylinder (line 65) | void rt_tri_fcylinder(void *tex, vector ctr, vector axis, apiflt rad) {
  function rt_tri_cylinder (line 113) | void rt_tri_cylinder(void *tex, vector ctr, vector axis, apiflt rad) {
  function rt_tri_ring (line 117) | void rt_tri_ring(void *tex, vector ctr, vector norm, apiflt a, apiflt b) {
  function rt_tri_box (line 164) | void rt_tri_box(void *tex, vector min, vector max) {
  function rt_tri_sphere (line 226) | void rt_tri_sphere(void *tex, vector ctr, apiflt rad) {}
  function rt_tri_plane (line 228) | void rt_tri_plane(void *tex, vector ctr, vector norm) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/bndbox.cpp
  function bndbox (line 65) | bndbox *newbndbox(vector min, vector max) {
  function bndbox_bbox (line 80) | static int bndbox_bbox(void *obj, vector *min, vector *max) {
  function free_bndbox (line 89) | static void free_bndbox(void *v) {
  function bndbox_intersect (line 97) | static void bndbox_intersect(bndbox *bx, ray *ry) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/box.cpp
  function box_bbox (line 58) | int box_bbox(void *obj, vector *min, vector *max) {
  function box (line 72) | box *newbox(void *tex, vector min, vector max) {
  function box_intersect (line 85) | void box_intersect(box *bx, ray *ry) {
  function box_normal (line 162) | void box_normal(box *bx, vector *pnt, ray *incident, vector *N) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/camera.cpp
  function ray (line 57) | ray camray(scenedef *scene, int x, int y) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/coordsys.cpp
  function xytopolar (line 54) | void xytopolar(flt x, flt y, flt rad, flt* u, flt* v) {
  function xyztocyl (line 64) | void xyztocyl(vector pnt, flt height, flt* u, flt* v) {
  function xyztospr (line 76) | void xyztospr(vector pnt, flt* u, flt* v) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/cylinder.cpp
  function object (line 72) | object *newcylinder(void *tex, vector ctr, vector axis, flt rad) {
  function cylinder_bbox (line 86) | static int cylinder_bbox(void *obj, vector *min, vector *max) {
  function cylinder_intersect (line 90) | static void cylinder_intersect(cylinder *cyl, ray *ry) {
  function cylinder_normal (line 134) | static void cylinder_normal(cylinder *cyl, vector *pnt, ray *incident, v...
  function object (line 160) | object *newfcylinder(void *tex, vector ctr, vector axis, flt rad) {
  function fcylinder_bbox (line 175) | static int fcylinder_bbox(void *obj, vector *min, vector *max) {
  function fcylinder_intersect (line 203) | static void fcylinder_intersect(cylinder *cyl, ray *ry) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/extvol.cpp
  function extvol_bbox (line 65) | int extvol_bbox(void *obj, vector *min, vector *max) {
  function extvol (line 79) | extvol *newextvol(void *voidtex,
  function color (line 127) | color ExtVoxelColor(flt scalar) {
  function color (line 149) | color ext_volume_texture(vector *hit, texture *tex, ray *ry) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/grid.cpp
  function object (line 76) | object *newgrid(int xsize, int ysize, int zsize, vector min, vector max) {
  function grid_bbox (line 105) | static int grid_bbox(void *obj, vector *min, vector *max) {
  function grid_free (line 114) | static void grid_free(void *v) {
  function globalbound (line 139) | static void globalbound(object **rootlist, vector *gmin, vector *gmax) {
  function cellbound (line 176) | static int cellbound(grid *g, gridindex *index, vector *cmin, vector *cm...
  function countobj (line 245) | static int countobj(object *root) {
  function countobjlist (line 259) | static int countobjlist(objectlist *root) {
  function engrid_scene (line 273) | int engrid_scene(object **list) {
  function engrid_objlist (line 311) | void engrid_objlist(grid *g, object **list) {
  function engrid_cell (line 332) | static int engrid_cell(grid *gold, gridindex *index) {
  function engrid_objectlist (line 381) | static int engrid_objectlist(grid *g, objectlist **list) {
  function engrid_object (line 409) | static int engrid_object(grid *g, object *obj) {
  function pos2grid (line 446) | static int pos2grid(grid *g, vector *pos, gridindex *index) {
  function grid_intersect (line 470) | static void grid_intersect(grid *g, ray *ry) {
  function voxel_intersect (line 623) | static void voxel_intersect(grid *g, ray *ry, int voxindex) {
  function grid_bounds_intersect (line 633) | static int grid_bounds_intersect(grid *g, ray *ry, flt *nr, flt *fr) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/grid.hpp
  type objectlist (line 58) | struct objectlist {
    type objectlist (line 59) | struct objectlist

FILE: third-party/tbb/examples/parallel_for/tachyon/src/imageio.cpp
  function fakeimage (line 63) | static int fakeimage(char *name, int *xres, int *yres, unsigned char **i...
  function readimage (line 79) | int readimage(rawimage *img) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/imap.cpp
  function ResetImages (line 59) | void ResetImages(void) {
  function LoadImage (line 67) | void LoadImage(rawimage *image) {
  function color (line 74) | color ImageMap(rawimage *image, flt u, flt v) {
  function rawimage (line 125) | rawimage *AllocateImage(char *filename) {
  function DeallocateImage (line 159) | void DeallocateImage(rawimage *image) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/intersect.cpp
  function new_objectid (line 57) | unsigned int new_objectid(void) {
  function max_objectid (line 61) | unsigned int max_objectid(void) {
  function add_object (line 65) | void add_object(object *obj) {
  function free_objects (line 78) | void free_objects(object *start) {
  function reset_object (line 91) | void reset_object(void) {
  function intersect_objects (line 99) | void intersect_objects(ray *intray) {
  function reset_intersection (line 110) | void reset_intersection(intersectstruct *intstruct) {
  function add_intersection (line 118) | void add_intersection(flt t, object *obj, ray *ry) {
  function closest_intersection (line 138) | int closest_intersection(flt *t, object **obj, intersectstruct *intstruc...
  function shadow_intersection (line 152) | int shadow_intersection(intersectstruct *intstruct, flt maxdist) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/jpeg.cpp
  function readjpeg (line 66) | int readjpeg(char *name, int *xres, int *yres, unsigned char **imgdata) {
  function readjpeg (line 74) | int readjpeg(char *name, int *xres, int *yres, unsigned char **imgdata) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/light.cpp
  function point_light (line 65) | point_light *newlight(void *tex, vector ctr, flt rad) {
  function light_bbox (line 79) | static int light_bbox(void *obj, vector *min, vector *max) {
  function light_intersect (line 83) | static void light_intersect(point_light *l, ray *ry) {
  function light_normal (line 111) | static void light_normal(point_light *l, vector *pnt, ray *incident, vec...

FILE: third-party/tbb/examples/parallel_for/tachyon/src/main.cpp
  class tachyon_video (line 77) | class tachyon_video
  function initoptions (line 93) | void initoptions(argoptions *opt) {
  function CreateScene (line 106) | int CreateScene() {
  function example_main (line 127) | unsigned int __stdcall example_main(void *) {
  function CreateScene (line 169) | int CreateScene() {
  function main (line 196) | int main(int argc, char *argv[]) {
  function useoptions (line 246) | int useoptions(argoptions *opt, SceneHandle scene) {
  function argoptions (line 274) | argoptions ParseCommandLine(int argc, const char *argv[]) {
  function CreateScene (line 302) | int CreateScene(argoptions &opt) {
  function main (line 342) | int main(int argc, char *argv[]) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/objbound.cpp
  function globalbound (line 59) | static void globalbound(object **rootlist, vector *gmin, vector *gmax) {
  function objinside (line 96) | static int objinside(object *obj, vector *min, vector *max) {
  function countobj (line 111) | static int countobj(object *root) {
  function movenextobj (line 125) | static void movenextobj(object *thisobj, object **root) {
  function octreespace (line 141) | static void octreespace(object **rootlist, int maxoctnodes) {
  function dividespace (line 325) | void dividespace(int maxoctnodes, object **toplist) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/parse.cpp
  function stringcmp (line 75) | static int stringcmp(const char *a, const char *b) {
  function reset_tex_table (line 92) | static void reset_tex_table(void) {
  function errcode (line 110) | static errcode add_texture(void *tex, char name[TEXNAMELEN]) {
  function apiflt (line 135) | apiflt degtorad(apiflt deg) {
  function degvectoradvec (line 141) | static void degvectoradvec(vector *degvec) {
  function InitRot3d (line 150) | static void InitRot3d(RotMat *rot, apiflt x, apiflt y, apiflt z) {
  function Rotate3d (line 164) | static void Rotate3d(RotMat *rot, vector *vec) {
  function Scale3d (line 172) | static void Scale3d(vector *scale, vector *vec) {
  function Trans3d (line 178) | static void Trans3d(vector *trans, vector *vec) {
  function errcode (line 184) | static errcode GetString(FILE *dfile, const char *string) {
  function readmodel (line 197) | unsigned int readmodel(char *modelfile, SceneHandle scene) {
  function errcode (line 233) | static errcode GetScenedefs(FILE *dfile, SceneHandle scene) {
  function errcode (line 301) | static errcode GetObject(FILE *dfile, SceneHandle scene) {
  function errcode (line 361) | static errcode GetVector(FILE *dfile, vector *v1) {
  function errcode (line 372) | static errcode GetColor(FILE *dfile, color *c1) {
  function errcode (line 385) | static errcode GetTexDef(FILE *dfile) {
  function errcode (line 394) | static errcode GetTexAlias(FILE *dfile) {
  function errcode (line 405) | static errcode GetTexture(FILE *dfile, void **tex) {
  function errcode (line 497) | static errcode GetLight(FILE *dfile) {
  function errcode (line 519) | static errcode GetBackGnd(FILE *dfile) {
  function errcode (line 531) | static errcode GetCylinder(FILE *dfile) {
  function errcode (line 552) | static errcode GetFCylinder(FILE *dfile) {
  function errcode (line 580) | static errcode GetPolyCylinder(FILE *dfile) {
  function errcode (line 609) | static errcode GetSphere(FILE *dfile) {
  function errcode (line 629) | static errcode GetPlane(FILE *dfile) {
  function errcode (line 646) | static errcode GetVol(FILE *dfile) {
  function errcode (line 668) | static errcode GetBox(FILE *dfile) {
  function errcode (line 684) | static errcode GetRing(FILE *dfile) {
  function errcode (line 706) | static errcode GetTri(FILE *dfile) {
  function errcode (line 727) | static errcode GetSTri(FILE *dfile) {
  function errcode (line 757) | static errcode GetLandScape(FILE *dfile) {
  function errcode (line 783) | static errcode GetTPolyFile(FILE *dfile) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/plane.cpp
  function object (line 65) | object *newplane(void *tex, vector ctr, vector norm) {
  function plane_bbox (line 80) | static int plane_bbox(void *obj, vector *min, vector *max) {
  function plane_intersect (line 84) | static void plane_intersect(plane *pln, ray *ry) {
  function plane_normal (line 96) | static void plane_normal(plane *pln, vector *pnt, ray *incident, vector ...

FILE: third-party/tbb/examples/parallel_for/tachyon/src/ppm.cpp
  function getint (line 67) | static int getint(FILE *dfile) {
  function readppm (line 83) | int readppm(char *name, int *xres, int *yres, unsigned char **imgdata) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/pthread.cpp
  function pthread_create (line 55) | int pthread_create(pthread_t *thread,
  function pthread_join (line 80) | int pthread_join(pthread_t th, void **thread_return) {
  function pthread_exit (line 113) | void pthread_exit(void *retval) {
  function pthread_mutex_init (line 127) | int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *mute...
  function pthread_mutex_destroy (line 132) | int pthread_mutex_destroy(pthread_mutex_t *mutex) {
  function pthread_mutex_lock (line 136) | int pthread_mutex_lock(pthread_mutex_t *mutex) {
  function pthread_mutex_unlock (line 141) | int pthread_mutex_unlock(pthread_mutex_t *mutex) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/pthread_w.hpp
  type pthread_s (line 68) | struct pthread_s {
  type pthread_s (line 72) | struct pthread_s

FILE: third-party/tbb/examples/parallel_for/tachyon/src/quadric.cpp
  function quadric_bbox (line 58) | int quadric_bbox(void *obj, vector *min, vector *max) {
  function quadric (line 68) | quadric *newquadric() {
  function quadric_intersect (line 81) | void quadric_intersect(quadric *q, ray *ry) {
  function quadric_normal (line 125) | void quadric_normal(quadric *q, vector *pnt, ray *incident, vector *N) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/render.cpp
  function renderscene (line 67) | void renderscene(scenedef scene) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/ring.cpp
  function object (line 65) | object *newring(void *tex, vector ctr, vector norm, flt inrad, flt outra...
  function ring_bbox (line 81) | static int ring_bbox(void *obj, vector *min, vector *max) {
  function ring_intersect (line 94) | static void ring_intersect(ring *rng, ray *ry) {
  function ring_normal (line 116) | static void ring_normal(ring *rng, vector *pnt, ray *incident, vector *N) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/shade.cpp
  function reset_lights (line 60) | void reset_lights(void) {
  function add_light (line 64) | void add_light(point_light* li) {
  function color (line 69) | color shader(ray* incident) {
  function color (line 181) | color shade_reflection(ray* incident, vector* hit, vector* N, flt specul...
  function color (line 210) | color shade_transmission(ray* incident, vector* hit, flt trans) {
  function flt (line 233) | flt shade_phong(ray* incident, vector* hit, vector* N, vector* L, flt sp...

FILE: third-party/tbb/examples/parallel_for/tachyon/src/sphere.cpp
  function object (line 65) | object *newsphere(void *tex, vector ctr, flt rad) {
  function sphere_bbox (line 79) | static int sphere_bbox(void *obj, vector *min, vector *max) {
  function sphere_intersect (line 92) | static void sphere_intersect(sphere *spr, ray *ry) {
  function sphere_normal (line 116) | static void sphere_normal(sphere *spr, vector *pnt, ray *incident, vecto...

FILE: third-party/tbb/examples/parallel_for/tachyon/src/tachyon_video.cpp
  function rt_finalize (line 110) | void rt_finalize(void) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/tachyon_video.hpp
  class tachyon_video (line 48) | class tachyon_video : public video {
  class tachyon_video (line 57) | class tachyon_video

FILE: third-party/tbb/examples/parallel_for/tachyon/src/texture.cpp
  function color (line 60) | color standard_texture(vector *hit, texture *tex, ray *ry) {
  function color (line 65) | color image_cyl_texture(vector *hit, texture *tex, ray *ry) {
  function color (line 91) | color image_sphere_texture(vector *hit, texture *tex, ray *ry) {
  function color (line 117) | color image_plane_texture(vector *hit, texture *tex, ray *ry) {
  function color (line 148) | color grit_texture(vector *hit, texture *tex, ray *ry) {
  function color (line 163) | color checker_texture(vector *hit, texture *tex, ray *ry) {
  function color (line 192) | color cyl_checker_texture(vector *hit, texture *tex, ray *ry) {
  function color (line 223) | color wood_texture(vector *hit, texture *tex, ray *ry) {
  function InitNoise (line 258) | void InitNoise(void) {
  function Noise (line 287) | int Noise(flt x, flt y, flt z) {
  function color (line 336) | color marble_texture(vector *hit, texture *tex, ray *ry) {
  function color (line 368) | color gnoise_texture(vector *hit, texture *tex, ray *ry) {
  function InitTextures (line 386) | void InitTextures(void) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/tgafile.cpp
  function createtgafile (line 57) | void createtgafile(char *name, unsigned short width, unsigned short heig...
  function writetgaregion (line 116) | void writetgaregion(void *voidofp,
  function readtga (line 154) | int readtga(char *name, int *xres, int *yres, unsigned char **imgdata) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/trace.omp.cpp
  function color_t (line 72) | static color_t render_one_pixel(int x,
  function parallel_thread (line 151) | static void parallel_thread(void) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/trace.serial.cpp
  function color_t (line 71) | static color_t render_one_pixel(int x,
  function parallel_thread (line 149) | static void parallel_thread(void) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/trace.simple.cpp
  function color_t (line 71) | static color_t render_one_pixel(int x,
  function parallel_thread (line 138) | static void parallel_thread(void) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/trace.taskq.cpp
  function color_t (line 79) | static color_t render_one_pixel(int x,
  function parallel_thread (line 158) | static void parallel_thread(patch *pchin, int depth) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/trace.tbb.cpp
  function color_t (line 102) | static color_t render_one_pixel(int x,
  class parallel_task (line 193) | class parallel_task {
    method parallel_task (line 248) | parallel_task() {}

FILE: third-party/tbb/examples/parallel_for/tachyon/src/trace.tbb1d.cpp
  function color_t (line 79) | static color_t render_one_pixel(int x,
  class parallel_task (line 158) | class parallel_task {
    method parallel_task (line 181) | parallel_task() {}

FILE: third-party/tbb/examples/parallel_for/tachyon/src/trace.threads.cpp
  function color_t (line 83) | static color_t render_one_pixel(int x,
  function schedule_thread_work (line 169) | static bool schedule_thread_work(int &y1, int &y2) {
  function parallel_thread (line 186) | static void parallel_thread(void *arg) {
  function get_num_cpus (line 216) | static int get_num_cpus(void) {
  function get_num_cpus (line 226) | static int get_num_cpus(void) {
  function get_num_cpus (line 237) | static int get_num_cpus(void) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/trace.threads2d.cpp
  function color_t (line 86) | static color_t render_one_pixel(int x,
  type work_queue_entry_s (line 168) | struct work_queue_entry_s {
    type work_queue_entry_s (line 170) | struct work_queue_entry_s
  function generate_work (line 175) | static void generate_work(patch *pchin) {
  function generate_worklist (line 216) | static void generate_worklist(void) {
  function schedule_thread_work (line 225) | static bool schedule_thread_work(patch &pch) {
  function parallel_thread (line 236) | static void parallel_thread(void *arg) {
  function get_num_cpus (line 268) | static int get_num_cpus(void) {
  function get_num_cpus (line 278) | static int get_num_cpus(void) {
  function get_num_cpus (line 289) | static int get_num_cpus(void) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/trace_rest.cpp
  function color (line 66) | color trace(ray *primary) {
  function trace_shm (line 89) | void trace_shm(scenedef scene, /*char * buffer,  */ int startx, int stop...
  function trace_region (line 107) | void trace_region(scenedef scene, void *tga, int startx, int starty, int...

FILE: third-party/tbb/examples/parallel_for/tachyon/src/triangle.cpp
  function object (line 70) | object *newtri(void *tex, vector v0, vector v1, vector v2) {
  function object (line 97) | object *newstri(void *tex, vector v0, vector v1, vector v2, vector n0, v...
  function tri_bbox (line 139) | static int tri_bbox(void *obj, vector *min, vector *max) {
  function tri_intersect (line 157) | static void tri_intersect(tri *trn, ray *ry) {
  function tri_normal (line 194) | static void tri_normal(tri *trn, vector *pnt, ray *incident, vector *N) {
  function stri_normal (line 206) | static void stri_normal(stri *trn, vector *pnt, ray *incident, vector *N) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/ui.cpp
  function set_rt_ui_message (line 62) | void set_rt_ui_message(void (*func)(int, const char *)) {
  function set_rt_ui_progress (line 66) | void set_rt_ui_progress(void (*func)(int)) {
  function rt_ui_message (line 70) | void rt_ui_message(int level, const char *msg) {
  function rt_ui_progress (line 82) | void rt_ui_progress(int percent) {
  function rt_ui_checkaction (line 93) | int rt_ui_checkaction(void) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/util.cpp
  function rt_sleep (line 64) | void rt_sleep(int msec) {
  function rt_sleep (line 73) | void rt_sleep(int msec) {
  function timer (line 82) | timer gettimer(void) {
  function flt (line 86) | flt timertime(timer st, timer fn) {
  type timezone (line 99) | struct timezone
  function timer (line 101) | timer gettimer(void) {
  function flt (line 107) | flt timertime(timer st, timer fn) {
  function timer (line 120) | timer gettimer(void) {
  function flt (line 124) | flt timertime(timer st, timer fn) {
  function rt_meminuse (line 131) | int rt_meminuse(void) {
  function rt_freemem (line 148) | unsigned int rt_freemem(void* addr) {
  function rtbomb (line 158) | void rtbomb(const char* msg) {
  function rtmesg (line 166) | void rtmesg(const char* msg) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/vector.cpp
  function flt (line 54) | flt VDot(vector *a, vector *b) {
  function VCross (line 58) | void VCross(vector *a, vector *b, vector *c) {
  function flt (line 64) | flt VLength(vector *a) {
  function VNorm (line 68) | void VNorm(vector *a) {
  function VAdd (line 79) | void VAdd(vector *a, vector *b, vector *c) {
  function VSub (line 85) | void VSub(vector *a, vector *b, vector *c) {
  function VAddS (line 91) | void VAddS(flt a, vector *A, vector *B, vector *C) {
  function vector (line 97) | vector Raypnt(ray *a, flt t) {
  function VScale (line 107) | void VScale(vector *a, flt s) {
  function ColorAddS (line 113) | void ColorAddS(color *a, color *b, flt s) {
  function ColorAccum (line 119) | void ColorAccum(color *a, color *b) {
  function ColorScale (line 125) | void ColorScale(color *a, flt s) {

FILE: third-party/tbb/examples/parallel_for/tachyon/src/vol.cpp
  function scalarvol_bbox (line 64) | int scalarvol_bbox(void *obj, vector *min, vector *max) {
  function color (line 130) | color VoxelColor(flt scalar) {
  function color (line 160) | color scalar_volume_texture(vector *hit, texture *tex, ray *ry) {
  function LoadVol (line 311) | void LoadVol(scalarvol *vol) {

FILE: third-party/tbb/examples/parallel_for_each/parallel_preorder/Graph.hpp
  type OpKind (line 25) | enum OpKind {
  class Cell (line 40) | class Cell {
    method Cell (line 64) | Cell() {}
  class Graph (line 71) | class Graph {

FILE: third-party/tbb/examples/parallel_for_each/parallel_preorder/Matrix.hpp
  class Matrix (line 20) | class Matrix {
    method Matrix (line 25) | Matrix() {}
    method Matrix (line 26) | Matrix(float z) {
    method Matrix (line 31) | Matrix operator-(const Matrix& x) {
    method Matrix (line 38) | Matrix operator+(const Matrix& x, const Matrix& y) {
    method Matrix (line 45) | Matrix operator-(const Matrix& x, const Matrix& y) {
    method Matrix (line 52) | Matrix operator*(const Matrix& x, const Matrix& y) {

FILE: third-party/tbb/examples/parallel_for_each/parallel_preorder/main.cpp
  class Cell (line 33) | class Cell
  function ParseCommandLine (line 44) | static void ParseCommandLine(int argc, char* argv[], utility::thread_num...
  function main (line 59) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/examples/parallel_for_each/parallel_preorder/parallel_preorder.cpp
  class Body (line 24) | class Body {
    method Body (line 26) | Body(){}
  function ParallelPreorderTraversal (line 49) | void ParallelPreorderTraversal(const std::vector<Cell*>& root_set) {

FILE: third-party/tbb/examples/parallel_pipeline/square/gen_input.cpp
  function gen_input (line 35) | void gen_input(const char *fname) {
  function generate_if_needed (line 57) | void generate_if_needed(const char *fname) {

FILE: third-party/tbb/examples/parallel_pipeline/square/square.cpp
  class TextSlice (line 40) | class TextSlice {
    method TextSlice (line 48) | static TextSlice* allocate(std::size_t max_size) {
    method free (line 57) | void free() {
    method size (line 70) | std::size_t size() const {
    method avail (line 74) | std::size_t avail() const {
    method append (line 78) | void append(char* first, char* last) {
    method set_end (line 83) | void set_end(char* p) {
  class MyInputFunc (line 94) | class MyInputFunc {
    method MyInputFunc (line 97) | MyInputFunc(const MyInputFunc& f) : input_file(f.input_file) {}
  function TextSlice (line 109) | TextSlice* MyInputFunc::operator()(oneapi::tbb::flow_control& fc) const {
    method TextSlice (line 48) | static TextSlice* allocate(std::size_t max_size) {
    method free (line 57) | void free() {
    method size (line 70) | std::size_t size() const {
    method avail (line 74) | std::size_t avail() const {
    method append (line 78) | void append(char* first, char* last) {
    method set_end (line 83) | void set_end(char* p) {
  class MyTransformFunc (line 139) | class MyTransformFunc {
  function TextSlice (line 144) | TextSlice* MyTransformFunc::operator()(TextSlice* input) const {
    method TextSlice (line 48) | static TextSlice* allocate(std::size_t max_size) {
    method free (line 57) | void free() {
    method size (line 70) | std::size_t size() const {
    method avail (line 74) | std::size_t avail() const {
    method append (line 78) | void append(char* first, char* last) {
    method set_end (line 83) | void set_end(char* p) {
  class MyOutputFunc (line 169) | class MyOutputFunc {
  function run_pipeline (line 190) | int run_pipeline(int nthreads) {
  function main (line 226) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/examples/parallel_reduce/convex_hull/convex_hull.hpp
  type cfg (line 40) | namespace cfg {
  type util (line 50) | namespace util {
    function ParseInputArgs (line 56) | void ParseInputArgs(int argc, char* argv[], utility::thread_number_ran...
    type point (line 73) | struct point {
      method point (line 81) | point() {}
      method point (line 82) | point(T _x, T _y) : x(_x), y(_y) {}
    type rng (line 89) | struct rng {
      method rng (line 92) | rng(std::size_t seed) : my_fast_random(seed) {}
    function GenerateRNDPoint (line 102) | point<T> GenerateRNDPoint(std::size_t& count, rng_functor_type random,...
    type edge (line 131) | struct edge {
      method edge (line 134) | edge(Index _p1, Index _p2) : start(_p1), end(_p2){}
    function cross_product (line 158) | double cross_product(const point<T>& start, const point<T>& end1, cons...
    function my_time_t (line 165) | my_time_t gettime() {
    function time_diff (line 169) | double time_diff(my_time_t start, my_time_t end) {
    function WriteResults (line 173) | void WriteResults(int nthreads, double initTime, double calcTime) {

FILE: third-party/tbb/examples/parallel_reduce/convex_hull/convex_hull_bench.cpp
  class FindXExtremum (line 38) | class FindXExtremum : public std::unary_function<const point_t &, void> {
    method FindXExtremum (line 42) | FindXExtremum(const point_t &frstPoint, extremumType exType_)
    method closerToExtremum (line 59) | bool closerToExtremum(const point_t &p) const {
    method FindXExtremum (line 320) | FindXExtremum(const pointVec_t &points_, extremumType exType_)
    method FindXExtremum (line 325) | FindXExtremum(const FindXExtremum &fxex, oneapi::tbb::split)
    method join (line 341) | void join(const FindXExtremum &rhs) {
    method point_t (line 347) | point_t extremeXPoint() {
    method closerToExtremum (line 355) | bool closerToExtremum(const point_t &p) const {
  function point_t (line 69) | point_t extremum(const pointVec_t &points) {
  class SplitByCP (line 74) | class SplitByCP : public std::unary_function<const point_t &, void> {
    method SplitByCP (line 81) | SplitByCP(point_t _p1, point_t _p2, pointVec_t &_reducedSet)
    method SplitByCP (line 384) | SplitByCP(point_t _p1, point_t _p2, const pointVec_t &_initialSet, poi...
    method SplitByCP (line 392) | SplitByCP(SplitByCP &sbcp, oneapi::tbb::split)
    method join (line 424) | void join(const SplitByCP &rhs) {
    method point_t (line 431) | point_t farthestPoint() const {
  function point_t (line 107) | point_t divide(const pointVec_t &P, pointVec_t &P_reduced, const point_t...
  function divide_and_conquer (line 123) | void divide_and_conquer(const pointVec_t &P, pointVec_t &H, point_t p1, ...
  function quickhull (line 141) | void quickhull(const pointVec_t &points, pointVec_t &hull) {
  function main (line 156) | int main(int argc, char *argv[]) {
  function appendVector (line 196) | void appendVector(const point_t *src, std::size_t srcSize, pointVec_t &d...
  function appendVector (line 200) | void appendVector(const pointVec_t &src, pointVec_t &dest) {
  function grow_vector_to_at_least (line 204) | void grow_vector_to_at_least(pointVec_t &vect, std::size_t size) {
  function appendVector (line 213) | void appendVector(mutex_t &insertMutex, const pointVec_t &src, pointVec_...
  function appendVector (line 218) | void appendVector(mutex_t &insertMutex, const point_t *src, std::size_t ...
  function grow_vector_to_at_least (line 223) | void grow_vector_to_at_least(mutex_t &mutex, pointVec_t &vect, std::size...
  class FillRNDPointsVector (line 231) | class FillRNDPointsVector {
    method FillRNDPointsVector (line 240) | explicit FillRNDPointsVector(pointVec_t &_points) : points(_points) {}
  class FillRNDPointsVector_buf (line 258) | class FillRNDPointsVector_buf {
    method FillRNDPointsVector_buf (line 267) | explicit FillRNDPointsVector_buf(pointVec_t &_points) : points(_points...
  function initialize (line 293) | void initialize(pointVec_t &points) {
  class FindXExtremum (line 314) | class FindXExtremum {
    method FindXExtremum (line 42) | FindXExtremum(const point_t &frstPoint, extremumType exType_)
    method closerToExtremum (line 59) | bool closerToExtremum(const point_t &p) const {
    method FindXExtremum (line 320) | FindXExtremum(const pointVec_t &points_, extremumType exType_)
    method FindXExtremum (line 325) | FindXExtremum(const FindXExtremum &fxex, oneapi::tbb::split)
    method join (line 341) | void join(const FindXExtremum &rhs) {
    method point_t (line 347) | point_t extremeXPoint() {
    method closerToExtremum (line 355) | bool closerToExtremum(const point_t &p) const {
  function point_t (line 365) | point_t extremum(const pointVec_t &P) {
  class SplitByCP (line 371) | class SplitByCP {
    method SplitByCP (line 81) | SplitByCP(point_t _p1, point_t _p2, pointVec_t &_reducedSet)
    method SplitByCP (line 384) | SplitByCP(point_t _p1, point_t _p2, const pointVec_t &_initialSet, poi...
    method SplitByCP (line 392) | SplitByCP(SplitByCP &sbcp, oneapi::tbb::split)
    method join (line 424) | void join(const SplitByCP &rhs) {
    method point_t (line 431) | point_t farthestPoint() const {
  class SplitByCP_buf (line 436) | class SplitByCP_buf {
    method SplitByCP_buf (line 449) | SplitByCP_buf(point_t _p1, point_t _p2, const pointVec_t &_initialSet,...
    method SplitByCP_buf (line 457) | SplitByCP_buf(SplitByCP_buf &sbcp, oneapi::tbb::split)
    method join (line 490) | void join(const SplitByCP_buf &rhs) {
    method point_t (line 497) | point_t farthestPoint() const {
  function point_t (line 508) | point_t divide(const pointVec_t &P, pointVec_t &P_reduced, const point_t...
  function divide_and_conquer (line 526) | void divide_and_conquer(const pointVec_t &P, pointVec_t &H, point_t p1, ...
  function quickhull (line 561) | void quickhull(const pointVec_t &points, pointVec_t &hull, bool buffered) {
  function main (line 585) | int main(int argc, char *argv[]) {
  function serial_initialize (line 654) | void serial_initialize(pointVec_t &points) {

FILE: third-party/tbb/examples/parallel_reduce/convex_hull/convex_hull_sample.cpp
  function appendVector (line 38) | void appendVector(const point_t *src, std::size_t srcSize, pointVec_t &d...
  function appendVector (line 42) | void appendVector(const pointVec_t &src, pointVec_t &dest) {
  class FillRNDPointsVector_buf (line 45) | class FillRNDPointsVector_buf {
    method FillRNDPointsVector_buf (line 51) | explicit FillRNDPointsVector_buf(pointVec_t &_points) : points(_points...
  function initialize (line 72) | void initialize(pointVec_t &points) {
  class FindXExtremum (line 92) | class FindXExtremum {
    method FindXExtremum (line 98) | FindXExtremum(const pointVec_t &points_, extremumType exType_)
    method FindXExtremum (line 103) | FindXExtremum(const FindXExtremum &fxex, oneapi::tbb::split)
    method join (line 121) | void join(const FindXExtremum &rhs) {
    method point_t (line 127) | point_t extremeXPoint() {
    method closerToExtremum (line 135) | bool closerToExtremum(const point_t &p) const {
  function point_t (line 145) | point_t extremum(const pointVec_t &P) {
  class SplitByCP_buf (line 151) | class SplitByCP_buf {
    method SplitByCP_buf (line 161) | SplitByCP_buf(point_t _p1, point_t _p2, const pointVec_t &_initialSet,...
    method SplitByCP_buf (line 169) | SplitByCP_buf(SplitByCP_buf &sbcp, oneapi::tbb::split)
    method join (line 198) | void join(const SplitByCP_buf &rhs) {
    method point_t (line 205) | point_t farthestPoint() const {
  function point_t (line 210) | point_t divide(const pointVec_t &P, pointVec_t &P_reduced, const point_t...
  function divide_and_conquer (line 228) | void divide_and_conquer(const pointVec_t &P, pointVec_t &H, point_t p1, ...
  function quickhull (line 246) | void quickhull(const pointVec_t &points, pointVec_t &hull) {
  function main (line 263) | int main(int argc, char *argv[]) {

FILE: third-party/tbb/examples/parallel_reduce/pi/common.h
  type std (line 22) | typedef std::size_t number_t;
  type pi_t (line 23) | typedef double pi_t;
  function pi_t (line 31) | inline pi_t pi_kernel(number_t i) {
  function pi_slice_kernel (line 36) | inline double pi_slice_kernel(number_t slice, number_t slice_size = chun...
  type threading (line 44) | struct threading {

FILE: third-party/tbb/examples/parallel_reduce/pi/main.cpp
  function compute_pi_serial (line 32) | double compute_pi_serial() {
  function main (line 49) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/examples/parallel_reduce/pi/pi.cpp
  type reduce_body (line 22) | struct reduce_body {
    method reduce_body (line 24) | reduce_body() : my_pi(0) {}
    method reduce_body (line 25) | reduce_body(reduce_body& x, tbb::split) : my_pi(0) {}
    method join (line 29) | void join(const reduce_body& y) {
  function compute_pi_parallel (line 34) | double compute_pi_parallel() {

FILE: third-party/tbb/examples/parallel_reduce/primes/main.cpp
  type RunOptions (line 32) | struct RunOptions {
    method RunOptions (line 44) | RunOptions(utility::thread_number_range threads_,
  function RunOptions (line 57) | static RunOptions ParseCommandLine(int argc, char* argv[]) {
    method RunOptions (line 44) | RunOptions(utility::thread_number_range threads_,
  function main (line 85) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/examples/parallel_reduce/primes/primes.cpp
  class Multiples (line 40) | class Multiples {
    method NumberType (line 41) | inline NumberType strike(NumberType start, NumberType limit, NumberTyp...
    method Multiples (line 64) | Multiples(NumberType n) {
    method NumberType (line 85) | NumberType find_primes_in_window(NumberType start, NumberType window_s...
    method Multiples (line 112) | Multiples(const Multiples& f, oneapi::tbb::split)
    method is_initialized (line 119) | bool is_initialized() const {
    method initialize (line 123) | void initialize(NumberType start) {
    method move (line 136) | void move(Multiples& other) {
  function NumberType (line 154) | NumberType SerialCountPrimes(NumberType n) {
  class SieveRange (line 173) | class SieveRange {
    method assert_okay (line 186) | bool assert_okay() const {
    method is_divisible (line 197) | bool is_divisible() const {
    method empty (line 200) | bool empty() const {
    method SieveRange (line 203) | SieveRange(SieveRange& r, oneapi::tbb::split)
    method NumberType (line 219) | NumberType begin() const {
    method NumberType (line 222) | NumberType end() const {
    method SieveRange (line 225) | SieveRange(NumberType begin, NumberType end, NumberType stride, Number...
  class Sieve (line 237) | class Sieve {
    method Sieve (line 246) | Sieve(NumberType n) : multiples(n), count(0) {}
    method join (line 271) | void join(Sieve& other) {
    method Sieve (line 277) | Sieve(Sieve& other, oneapi::tbb::split)
  function NumberType (line 287) | NumberType ParallelCountPrimes(NumberType n, int number_of_threads, Numb...

FILE: third-party/tbb/examples/task_arena/fractal/fractal.cpp
  function color_t (line 31) | color_t fractal::calc_one_pixel(int x0, int y0) const {
  class fractal_body (line 118) | class fractal_body {
    method fractal_body (line 127) | fractal_body(fractal &_f) : f(_f) {}

FILE: third-party/tbb/examples/task_arena/fractal/fractal.hpp
  class fractal (line 29) | class fractal {
    method fractal (line 57) | fractal(const drawing_memory &dm) : step(0.2), dm(dm) {
    method move_up (line 68) | void move_up() {
    method move_down (line 71) | void move_down() {
    method move_left (line 74) | void move_left() {
    method move_right (line 77) | void move_right() {
    method zoom_in (line 81) | void zoom_in() {
    method zoom_out (line 85) | void zoom_out() {
    method quality_inc (line 90) | void quality_inc() {
    method quality_dec (line 93) | void quality_dec() {
  class fractal_group (line 101) | class fractal_group {
    type BORDER_TYPE (line 113) | enum BORDER_TYPE { BORDER_INACTIVE = 0, BORDER_ACTIVE }
    method get_num_threads (line 138) | int get_num_threads() const {
    method fractal (line 146) | fractal &get_active_fractal() {
    method active_fractal_zoom_in (line 150) | void active_fractal_zoom_in() {
    method active_fractal_zoom_out (line 154) | void active_fractal_zoom_out() {
    method active_fractal_quality_inc (line 158) | void active_fractal_quality_inc() {
    method active_fractal_quality_dec (line 162) | void active_fractal_quality_dec() {
    method active_fractal_move_up (line 166) | void active_fractal_move_up() {
    method active_fractal_move_down (line 170) | void active_fractal_move_down() {
    method active_fractal_move_left (line 174) | void active_fractal_move_left() {
    method active_fractal_move_right (line 178) | void active_fractal_move_right() {

FILE: third-party/tbb/examples/task_arena/fractal/fractal_video.hpp
  class fractal_video (line 27) | class fractal_video : public video {
    method on_mouse (line 31) | void on_mouse(int x, int y, int key) {
    method on_key (line 40) | void on_key(int key) {
    method on_process (line 83) | void on_process() {
    method fractal_video (line 90) | fractal_video() : fg(nullptr) {
    method set_fractal_group (line 95) | void set_fractal_group(fractal_group &_fg) {

FILE: third-party/tbb/examples/task_arena/fractal/main.cpp
  function main (line 35) | int main(int argc, char *argv[]) {

FILE: third-party/tbb/examples/task_group/sudoku/sudoku.cpp
  function read_board (line 49) | void read_board(const char* filename) {
  function print_board (line 68) | void print_board(const std::vector<board_element>& b) {
  function print_potential_board (line 81) | void print_potential_board(const std::vector<board_element>& b) {
  function init_board (line 97) | void init_board(std::vector<board_element>& b) {
  function init_board (line 102) | void init_board(std::vector<board_element>& b, unsigned short arr[BOARD_...
  function init_potentials (line 109) | void init_potentials(std::vector<board_element>& b) {
  function fixed_board (line 114) | bool fixed_board(const std::vector<board_element>& b) {
  function in_row (line 121) | bool in_row(const std::vector<board_element>& b, unsigned row, unsigned ...
  function in_col (line 128) | bool in_col(const std::vector<board_element>& b, unsigned row, unsigned ...
  function in_block (line 135) | bool in_block(const std::vector<board_element>& b, unsigned row, unsigne...
  function calculate_potentials (line 144) | void calculate_potentials(std::vector<board_element>& b) {
  function valid_board (line 158) | bool valid_board(const std::vector<board_element>& b) {
  function examine_potentials (line 172) | bool examine_potentials(std::vector<board_element>& b, bool& progress) {
  function partial_solve (line 229) | void partial_solve(oneapi::tbb::task_group& g,
  function solve (line 263) | unsigned solve(int p) {
  function main (line 276) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/examples/test_all/fibonacci/fibonacci.cpp
  type Matrix2x2 (line 57) | struct Matrix2x2 {
    method Matrix2x2 (line 60) | Matrix2x2() {}
    method Matrix2x2 (line 61) | Matrix2x2(value v00, value v01, value v10, value v11) {
  function value (line 79) | value SerialFib(int n) {
  function value (line 92) | value SerialMatrixFib(int n) {
  function value (line 104) | value SerialRecursiveFib(int n) {
  function yield (line 115) | static inline void yield() {
  function value (line 123) | value SerialQueueFib(int n) {
  function value (line 140) | value SerialVectorFib(int n) {
  class SharedSerialFibBody (line 162) | class SharedSerialFibBody {
    method SharedSerialFibBody (line 166) | SharedSerialFibBody(M &m) : mutex(m) {}
  function value (line 197) | value SharedSerialFib(int n) {
  type IntHashCompare (line 210) | struct IntHashCompare {
    method equal (line 211) | bool equal(const int j, const int k) const {
    method hash (line 214) | std::size_t hash(const int k) const {
  class ConcurrentHashSerialFibTask (line 221) | class ConcurrentHashSerialFibTask {
    method ConcurrentHashSerialFibTask (line 227) | ConcurrentHashSerialFibTask(NumbersTable &cht, int n) : Fib(cht), my_n...
  function value (line 246) | value ConcurrentHashSerialFib(int n) {
  type parallel_pipeline_ns (line 269) | namespace parallel_pipeline_ns {
  type InputFunc (line 275) | struct InputFunc {
    method InputFunc (line 276) | InputFunc() {}
    method queue_t (line 277) | queue_t *operator()(oneapi::tbb::flow_control &fc) const {
  type MultiplyFunc (line 290) | struct MultiplyFunc {
    method MultiplyFunc (line 291) | MultiplyFunc() {}
  function value (line 305) | value ParallelPipeFib(int n) {
  type parallel_reduceFibBody (line 329) | struct parallel_reduceFibBody {
    method parallel_reduceFibBody (line 333) | parallel_reduceFibBody() : sum(Matrix1110), split_flag(0) {}
    method parallel_reduceFibBody (line 335) | parallel_reduceFibBody(parallel_reduceFibBody &other, oneapi::tbb::split)
    method join (line 339) | void join(parallel_reduceFibBody &s) {
  function value (line 350) | value parallel_reduceFib(int n) {
  type parallel_scanFibBody (line 360) | struct parallel_scanFibBody {
    method parallel_scanFibBody (line 367) | parallel_scanFibBody(value *output_) : product(MatrixIdentity), output...
    method parallel_scanFibBody (line 369) | parallel_scanFibBody(parallel_scanFibBody &b, oneapi::tbb::split)
    method reverse_join (line 373) | void reverse_join(parallel_scanFibBody &a) {
    method assign (line 381) | void assign(parallel_scanFibBody &b) {
  function value (line 399) | value parallel_scanFib(int n) {
  type IntRange (line 413) | struct IntRange {
    method IntRange (line 417) | IntRange(int low_, int high_) : low(low_), high(high_) {}
  function value (line 438) | value Measure(const char *name, MeasureFunc func, int n) {
  function main (line 451) | int main(int argc, char *argv[]) {
  function Matrix2x2Multiply (line 516) | void Matrix2x2Multiply(const value a[2][2], const value b[2][2], value c...
  function Matrix2x2 (line 522) | Matrix2x2 Matrix2x2::operator*(const Matrix2x2 &to) const {
    method Matrix2x2 (line 60) | Matrix2x2() {}
    method Matrix2x2 (line 61) | Matrix2x2(value v00, value v01, value v10, value v11) {

FILE: third-party/tbb/include/oneapi/tbb/blocked_nd_range.h
  function namespace (line 32) | namespace tbb {
  function namespace (line 190) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/blocked_range.h
  function namespace (line 27) | namespace tbb {
  function namespace (line 160) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/blocked_range2d.h
  function namespace (line 28) | namespace tbb {
  function namespace (line 106) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/blocked_range3d.h
  function namespace (line 27) | namespace tbb {
  function namespace (line 125) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/blocked_rangeNd.h
  function namespace (line 35) | namespace tbb {
  function namespace (line 141) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/cache_aligned_allocator.h
  function namespace (line 29) | namespace tbb {
  function namespace (line 180) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/collaborative_call_once.h
  function namespace (line 25) | namespace tbb {
  function class (line 152) | class collaborative_once_flag : no_copy {

FILE: third-party/tbb/include/oneapi/tbb/combinable.h
  function namespace (line 25) | namespace tbb {
  function namespace (line 62) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/concurrent_hash_map.h
  function namespace (line 38) | namespace tbb {
  function delete_segment (line 217) | void delete_segment( segment_index_type s ) {
  function bucket (line 240) | bucket *get_bucket( hashcode_type h ) const noexcept {
  function mark_rehashed_levels (line 249) | void mark_rehashed_levels( hashcode_type h ) noexcept {
  function check_mask_race (line 260) | inline bool check_mask_race( const hashcode_type h, hashcode_type &m ) c...
  function check_rehashing_collision (line 270) | bool check_rehashing_collision( const hashcode_type h, hashcode_type m_o...
  function segment_index_type (line 288) | segment_index_type insert_new_node( bucket *b, node_base *n, hashcode_ty...
  function reserve (line 305) | void reserve(size_type buckets) {
  function internal_swap_content (line 316) | void internal_swap_content(hash_map_base &table) {
  function internal_move (line 335) | void internal_move(hash_map_base&& other) {
  function advance_to_next_bucket (line 438) | void advance_to_next_bucket() { // TODO?: refactor to iterator_base class
  function pointer (line 650) | pointer storage() { return &my_value; }
  function delete_node (line 658) | void delete_node( node_base *n ) {
  function guard (line 669) | auto guard = make_raii_guard([&] {
  function node (line 680) | static node* allocate_node_copy_construct(bucket_allocator_type& allocat...
  function node (line 684) | static node* allocate_node_move_construct(bucket_allocator_type& allocat...
  function class (line 710) | class bucket_accessor : public bucket::scoped_type {
  function bucket (line 728) | bucket *operator() () { return my_b; }
  function rehash_bucket (line 732) | void rehash_bucket( bucket *b_new, const hashcode_type hash ) {
  function class (line 775) | class const_accessor : private node::scoped_type /*which derived from no...
  function class (line 822) | class accessor: public const_accessor {
  function concurrent_hash_map (line 844) | concurrent_hash_map(hash_compare_type()) {}
  function explicit (line 846) | explicit concurrent_hash_map( const allocator_type& a )
  function concurrent_hash_map (line 864) | concurrent_hash_map( const concurrent_hash_map &table )
  function concurrent_hash_map (line 875) | concurrent_hash_map(a)
  function concurrent_hash_map (line 893) | concurrent_hash_map(a)
  function concurrent_hash_map (line 902) | concurrent_hash_map(a)
  function clear (line 1012) | void clear() {
  function iterator (line 1050) | iterator begin() { return iterator( *this, 0, this->my_embedded_segment,...
  function iterator (line 1053) | iterator end() { return iterator( *this, 0, nullptr, nullptr ); }
  function size_type (line 1078) | size_type max_size() const {
  function allocator_type (line 1086) | allocator_type get_allocator() const { return base_type::get_allocator(); }
  function size_type (line 1101) | size_type count( const Key &key ) const {
  function find (line 1113) | bool find( const_accessor &result, const Key &key ) const {
  function find (line 1120) | bool find( accessor &result, const Key &key ) {
  function insert (line 1141) | bool insert( const_accessor &result, const Key &key ) {
  function insert (line 1148) | bool insert( accessor &result, const Key &key ) {
  function insert (line 1171) | bool insert( const_accessor &result, const value_type &value ) {
  function insert (line 1178) | bool insert( accessor &result, const value_type &value ) {
  function insert (line 1185) | bool insert( const value_type &value ) {
  function insert (line 1191) | bool insert( const_accessor &result, value_type && value ) {
  function insert (line 1197) | bool insert( accessor &result, value_type && value ) {
  function insert (line 1203) | bool insert( value_type && value ) {
  function insert (line 1236) | void insert( std::initializer_list<value_type> il ) {
  function erase (line 1242) | bool erase( const Key &key ) {
  function erase (line 1254) | bool erase( const_accessor& item_accessor ) {
  function erase (line 1260) | bool erase( accessor& item_accessor ) {
  type accessor_not_used (line 1363) | struct accessor_not_used { void release(){}};
  function friend (line 1367) | friend bool is_write_access_needed( accessor const& )           { return...
  function friend (line 1368) | friend bool is_write_access_needed( const_accessor const& )     { return...
  function friend (line 1369) | friend bool is_write_access_needed( accessor_not_used const& )  { return...
  function exclude (line 1385) | bool exclude( const_accessor &item_accessor ) {
  function internal_copy (line 1490) | void internal_copy( const concurrent_hash_map& source ) {
  function internal_move_construct_with_allocator (line 1528) | void internal_move_construct_with_allocator( concurrent_hash_map&& other...
  function internal_move_construct_with_allocator (line 1534) | void internal_move_construct_with_allocator( concurrent_hash_map&& other...
  function internal_move_assign (line 1549) | void internal_move_assign( concurrent_hash_map&& other,
  function internal_move_assign (line 1555) | void internal_move_assign(concurrent_hash_map&& other, /*is_always_equal...
  function internal_swap (line 1565) | void internal_swap(concurrent_hash_map& other, /*is_always_equal || POCS...
  function internal_swap (line 1569) | void internal_swap(concurrent_hash_map& other, /*is_always_equal || POCS...
  function const_pointer (line 1577) | const_pointer internal_fast_find( const Key& key ) const {
  function namespace (line 1660) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/concurrent_lru_cache.h
  function namespace (line 33) | namespace tbb {
  function namespace (line 367) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/concurrent_map.h
  function namespace (line 27) | namespace tbb {
  function namespace (line 341) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/concurrent_priority_queue.h
  function namespace (line 36) | namespace tbb {
  function assign (line 159) | void assign( std::initializer_list<value_type> init ) {
  function push (line 173) | void push( const value_type& value ) {
  function push (line 181) | void push( value_type&& value ) {
  function try_pop (line 199) | bool try_pop( value_type& value ) {
  function clear (line 206) | void clear() {
  function swap (line 213) | void swap( concurrent_priority_queue& other ) {
  type operation_type (line 227) | enum operation_type {INVALID_OP, PUSH_OP, POP_OP, PUSH_RVALUE_OP}
  type operation_status (line 228) | enum operation_status {WAIT = 0, SUCCEEDED, FAILED}
  function class (line 230) | class cpq_operation : public aggregated_operation<cpq_operation> {
  function class (line 241) | class functor {
  function handle_operations (line 253) | void handle_operations( cpq_operation* op_list ) {
  function heapify (line 344) | void heapify() {
  function reheap (line 363) | void reheap() {
  function push_back_helper (line 383) | void push_back_helper( const T& value ) {
  function push_back_helper_impl (line 387) | void push_back_helper_impl( const T& value, /*is_copy_constructible = */...
  function push_back_helper_impl (line 391) | void push_back_helper_impl( const T&, /*is_copy_constructible = */std::f...
  function namespace (line 484) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/concurrent_queue.h
  function namespace (line 27) | namespace tbb {
  function internal_pop (line 604) | void internal_pop( void* dst ) {
  function internal_pop_if_present (line 632) | bool internal_pop_if_present( void* dst ) {
  function internal_abort (line 643) | void internal_abort() {
  function copy_construct_item (line 648) | static void copy_construct_item(T* location, const void* src) {
  function move_construct_item (line 653) | static void move_construct_item(T* location, const void* src) {
  function namespace (line 694) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/concurrent_set.h
  function namespace (line 26) | namespace tbb {
  function namespace (line 258) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/concurrent_unordered_map.h
  function namespace (line 25) | namespace tbb {
  function namespace (line 405) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/concurrent_unordered_set.h
  function namespace (line 24) | namespace tbb {
  function namespace (line 324) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/concurrent_vector.h
  function namespace (line 36) | namespace tbb {
  function explicit (line 283) | explicit concurrent_vector( const allocator_type& alloc ) noexcept
  function explicit (line 287) | explicit concurrent_vector( size_type count, const value_type& value,
  function concurrent_vector (line 299) | concurrent_vector(alloc)
  function concurrent_vector (line 310) | concurrent_vector(alloc)
  function base_type (line 319) | concurrent_vector( const concurrent_vector& other )
  function noexcept (line 353) | noexcept(is_noexcept_assignment) {
  function assign (line 363) | void assign( size_type count, const value_type& value ) {
  function assign (line 375) | void assign( std::initializer_list<value_type> init ) {
  function iterator (line 381) | iterator grow_by( size_type delta ) {
  function iterator (line 385) | iterator grow_by( size_type delta, const value_type& value ) {
  function iterator (line 396) | iterator grow_by( std::initializer_list<value_type> init ) {
  function iterator (line 400) | iterator grow_to_at_least( size_type n ) {
  function iterator (line 403) | iterator grow_to_at_least( size_type n, const value_type& value ) {
  function iterator (line 407) | iterator push_back( const value_type& item ) {
  function iterator (line 411) | iterator push_back( value_type&& item ) {
  function reference (line 421) | reference operator[]( size_type index ) {
  function const_reference (line 424) | const_reference operator[]( size_type index ) const {
  function reference (line 428) | reference at( size_type index ) {
  function const_reference (line 431) | const_reference at( size_type index ) const {
  function reference (line 445) | reference front() {
  function reference (line 453) | reference back() {
  function iterator (line 462) | iterator begin() { return iterator(*this, 0); }
  function iterator (line 466) | iterator end() { return iterator(*this, size()); }
  function reverse_iterator (line 470) | reverse_iterator rbegin() { return reverse_iterator(end()); }
  function const_reverse_iterator (line 471) | const_reverse_iterator rbegin() const { return const_reverse_iterator(en...
  function reverse_iterator (line 474) | reverse_iterator rend() { return reverse_iterator(begin()); }
  function allocator_type (line 478) | allocator_type get_allocator() const {
  function size_type (line 487) | size_type size() const noexcept {
  function size_type (line 495) | size_type capacity() const noexcept {
  function resize (line 510) | void resize( size_type n ) {
  function resize (line 514) | void resize( size_type n, const value_type& val ) {
  function shrink_to_fit (line 518) | void shrink_to_fit() {
  function swap (line 522) | void swap(concurrent_vector& other) noexcept(is_noexcept_swap) {
  function clear (line 526) | void clear() {
  function segment_table_type (line 540) | segment_table_type allocate_long_table( const typename base_type::atomic...
  function segment_type (line 569) | segment_type create_segment( segment_table_type table, segment_index_typ...
  function size_type (line 632) | size_type number_of_elements_in_segment( segment_index_type seg_index ) {
  function segment_type (line 647) | segment_type nullify_segment( segment_table_type table, size_type segmen...
  function deallocate_segment (line 662) | void deallocate_segment( segment_type address, segment_index_type seg_in...
  function destroy_segment (line 675) | void destroy_segment( segment_type address, segment_index_type seg_index...
  function copy_segment (line 687) | void copy_segment( segment_index_type seg_index, segment_type from, segm...
  function move_segment (line 710) | void move_segment( segment_index_type seg_index, segment_type from, segm...
  function is_first_element_in_segment (line 732) | static constexpr bool is_first_element_in_segment( size_type index ) {
  function const_reference (line 737) | const_reference internal_subscript( size_type index ) const {
  function reference (line 741) | reference internal_subscript( size_type index ) {
  function const_reference (line 746) | const_reference internal_subscript_with_exceptions( size_type index ) co...
  function reference (line 750) | reference internal_subscript_with_exceptions( size_type index ) {
  function zero_unconstructed_elements (line 769) | static void zero_unconstructed_elements( pointer start, size_type count ) {
  function value_guard (line 781) | auto value_guard = make_raii_guard([&] {
  function value_guard (line 797) | auto value_guard = make_raii_guard( [&] {
  function destroy_elements (line 933) | void destroy_elements() {
  function incompact_predicate (line 941) | static bool incompact_predicate( size_type size ) {
  function internal_compact (line 947) | void internal_compact() {
  function namespace (line 1123) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/detail/_aggregator.h
  function namespace (line 28) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_aligned_space.h
  function namespace (line 23) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_allocator_traits.h
  function namespace (line 25) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_assert.h
  function namespace (line 23) | namespace rml { namespace internal {

FILE: third-party/tbb/include/oneapi/tbb/detail/_attach.h
  function namespace (line 22) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_concurrent_queue_base.h
  function namespace (line 31) | namespace tbb {
  function invalidate_page (line 263) | void invalidate_page( ticket_type k )  {
  function padded_page (line 279) | padded_page* get_head_page() {
  function clear_and_invalidate (line 308) | void clear_and_invalidate(queue_allocator_type& allocator) {
  function class (line 318) | class destroyer  {
  function copy_item (line 327) | void copy_item( padded_page& dst, size_type dindex, const padded_page& s...
  function assign_and_destroy_item (line 334) | void assign_and_destroy_item( void* dst, padded_page& src, size_type ind...
  function spin_wait_until_my_turn (line 340) | void spin_wait_until_my_turn( std::atomic<ticket_type>& counter, ticket_...
  function spin_mutex (line 357) | spin_mutex page_mutex{}
  function clear (line 434) | void clear( queue_allocator_type& alloc ) {
  function assign (line 443) | void assign( const concurrent_queue_rep& src, queue_allocator_type& allo...
  function empty (line 468) | bool empty() const {
  function std (line 499) | alignas(max_nfs_size) std::atomic<ticket_type> head_counter{}
  function std (line 500) | alignas(max_nfs_size) std::atomic<ticket_type> tail_counter{}
  function std (line 501) | alignas(max_nfs_size) std::atomic<size_type> n_invalid_entries{}
  function assign (line 530) | void assign( const concurrent_queue_iterator_base& other ) {
  function advance (line 543) | void advance() {
  function get_item (line 566) | bool get_item( Value*& item, std::size_t k ) {
  function Value (line 579) | Value* my_item{ nullptr };

FILE: third-party/tbb/include/oneapi/tbb/detail/_concurrent_skip_list.h
  function namespace (line 50) | namespace tbb {
  function class (line 665) | class const_range_type {
  function class (line 713) | class range_type : public const_range_type {
  function range_type (line 733) | range_type range() { return range_type(*this); }
  function internal_move (line 742) | void internal_move(concurrent_skip_list&& other) {
  function internal_move_construct_with_allocator (line 753) | void internal_move_construct_with_allocator(concurrent_skip_list&& other,
  function internal_move_construct_with_allocator (line 758) | void internal_move_construct_with_allocator(concurrent_skip_list&& other,
  function key_type (line 769) | static const key_type& get_key( node_ptr n ) {
  function fill_prev_array_for_existing_node (line 909) | void fill_prev_array_for_existing_node( array_type& prev_nodes, node_ptr...
  type not_greater_compare (line 922) | struct not_greater_compare {
  function not_greater_compare (line 933) | not_greater_compare select_comparator( /*allow_multimapping = */ std::tr...
  function key_compare (line 937) | key_compare select_comparator( /*allow_multimapping = */ std::false_type...
  function node_ptr (line 1097) | node_ptr create_node( size_type height ) {
  function value_guard (line 1107) | auto value_guard = make_raii_guard([&] {
  function node_ptr (line 1117) | node_ptr create_head_node() {
  function delete_head (line 1121) | void delete_head() {
  function delete_node (line 1129) | void delete_node( node_ptr node ) {
  function delete_value_node (line 1133) | void delete_value_node( node_ptr node ) {
  function node_ptr (line 1143) | node_ptr create_head_if_necessary() {
  function iterator (line 1161) | static iterator get_iterator( const_iterator it ) {
  function internal_move_assign (line 1165) | void internal_move_assign( concurrent_skip_list&& other, /*POCMA || is_a...
  function internal_move_assign (line 1169) | void internal_move_assign( concurrent_skip_list&& other, /*POCMA || is_a...
  function internal_swap_fields (line 1177) | void internal_swap_fields( concurrent_skip_list& other ) {
  function internal_swap (line 1188) | void internal_swap( concurrent_skip_list& other, /*POCMA || is_always_eq...
  function internal_swap (line 1192) | void internal_swap( concurrent_skip_list& other, /*POCMA || is_always_eq...

FILE: third-party/tbb/include/oneapi/tbb/detail/_concurrent_unordered_base.h
  function namespace (line 47) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_containers_helpers.h
  function namespace (line 26) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_exception.h
  function namespace (line 27) | namespace detail {

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_body_impl.h
  type std (line 26) | typedef std::uint64_t tag_value;
  function namespace (line 46) | namespace graph_policy_namespace {
  function Output (line 89) | Output operator()(d1::flow_control& fc) override { return body(fc); }
  function input_body_leaf (line 90) | input_body_leaf* clone() override {
  function Body (line 93) | Body get_body() { return body; }
  function Output (line 112) | Output operator()(const Input &i) override { return tbb::detail::invoke(...
  function B (line 113) | B get_body() { return body; }
  function function_body_leaf (line 114) | function_body_leaf* clone() override {
  function body (line 125) | function_body_leaf( const B &_body ) : body(_body) { }
  function continue_msg (line 126) | continue_msg operator()( const continue_msg &i ) override {
  function B (line 130) | B get_body() { return body; }
  function function_body_leaf (line 131) | function_body_leaf* clone() override {
  function body (line 142) | function_body_leaf( const B &_body ) : body(_body) { }
  function continue_msg (line 143) | continue_msg operator()(const Input &i) override {
  function B (line 147) | B get_body() { return body; }
  function function_body_leaf (line 148) | function_body_leaf* clone() override {
  function body (line 159) | function_body_leaf( const B &_body ) : body(_body) { }
  function Output (line 160) | Output operator()(const continue_msg &i) override {
  function B (line 163) | B get_body() { return body; }
  function function_body_leaf (line 164) | function_body_leaf* clone() override {
  function override (line 186) | void operator()(const Input &input, OutputSet &oset) override {
  function multifunction_body_leaf (line 190) | multifunction_body_leaf* clone() override {
  function Output (line 221) | Output operator()(const Input &i) override { return tbb::detail::invoke(...
  function type_to_key_function_body_leaf (line 222) | type_to_key_function_body_leaf* clone() override {
  function body (line 232) | type_to_key_function_body_leaf( const B &_body ) : body(_body) { }
  function Output (line 233) | const Output& operator()(const Input &i) override {
  function type_to_key_function_body_leaf (line 236) | type_to_key_function_body_leaf* clone() override {
  function graph_task (line 286) | graph_task* call_apply_body_bypass_impl(without_metainfo) {
  function graph_task (line 292) | graph_task* call_apply_body_bypass_impl(with_metainfo) {
  function graph_task (line 297) | graph_task* call_apply_body_bypass() {
  function graph_task (line 378) | graph_task* try_put_task(const DecrementType& value, const message_metai...
  function override (line 383) | const override {
  function reset_receiver (line 388) | void reset_receiver( reset_flags ) {}
  function graph_task (line 405) | graph_task* execute(const message_metainfo&) override {

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_cache_impl.h
  function empty (line 33) | bool empty() {
  function add (line 38) | void add( T &n ) {
  function remove (line 43) | void remove( T &n ) {
  function clear (line 53) | void clear() {
  function internal_empty (line 64) | inline bool internal_empty( )  {
  function size_type (line 69) | inline size_type internal_size( )  {
  function internal_push (line 74) | inline void internal_push( T &n )  {
  function T (line 79) | inline T &internal_pop() {
  type T (line 92) | typedef T output_type;
  type sender (line 93) | typedef sender<output_type> predecessor_type;
  type receiver (line 94) | typedef receiver<output_type> successor_type;
  function my_owner (line 96) | my_owner( owner ) {
  function get_item (line 144) | bool get_item( output_type& v, message_metainfo& metainfo ) {
  function reset (line 150) | void reset() {
  type T (line 170) | typedef T output_type;
  type sender (line 171) | typedef sender<T> predecessor_type;
  type receiver (line 172) | typedef receiver<T> successor_type;
  function try_reserve (line 224) | bool try_reserve( output_type& v, message_metainfo& metainfo ) {
  function try_release (line 229) | bool try_release() {
  function try_consume (line 235) | bool try_consume() {
  function reset (line 241) | void reset() {
  function clear (line 246) | void clear() {
  type receiver (line 264) | typedef receiver<T> successor_type;
  type receiver (line 265) | typedef receiver<T>* pointer_type;
  type sender (line 266) | typedef sender<T> owner_type;
  type std (line 268) | typedef std::list< pointer_type > successors_type;
  function virtual (line 278) | virtual ~successor_cache() {}
  function register_successor (line 280) | void register_successor( successor_type& r ) {
  function remove_successor (line 288) | void remove_successor( successor_type& r ) {
  function empty (line 299) | bool empty() {
  function clear (line 304) | void clear() {
  type receiver (line 322) | typedef receiver<continue_msg> successor_type;
  type receiver (line 323) | typedef receiver<continue_msg>* pointer_type;
  type sender (line 324) | typedef sender<continue_msg> owner_type;
  type std (line 325) | typedef std::list< pointer_type > successors_type;
  function virtual (line 334) | virtual ~successor_cache() {}
  function register_successor (line 336) | void register_successor( successor_type& r ) {
  function remove_successor (line 348) | void remove_successor( successor_type& r ) {
  function empty (line 361) | bool empty() {
  function clear (line 366) | void clear() {
  type M (line 380) | typedef M mutex_type;
  type typename (line 381) | typedef typename successor_cache<T,M>::successors_type successors_type;
  function graph_task (line 383) | graph_task* try_put_task_impl( const T& t __TBB_FLOW_GRAPH_METAINFO_ARG(...
  function graph_task (line 411) | graph_task* try_put_task( const T &t ) override {
  function graph_task (line 416) | graph_task* try_put_task( const T &t, const message_metainfo& metainfo )...
  function gather_successful_try_puts (line 422) | bool gather_successful_try_puts( const T &t, graph_task_list& tasks ) {
  type size_type (line 451) | typedef size_t size_type;
  type M (line 452) | typedef M mutex_type;
  type typename (line 453) | typedef typename successor_cache<T,M>::successors_type successors_type;
  function size_type (line 461) | size_type size() {
  function graph_task (line 495) | graph_task* try_put_task( const T& t, const message_metainfo& metainfo )...

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_impl.h
  function namespace (line 30) | namespace tbb {
  type tbb (line 224) | typedef tbb::concurrent_priority_queue<graph_task*, graph_task_comparato...
  function class (line 226) | class priority_task_selector : public d1::task {
  function class (line 271) | class graph_task_list : no_copy {
  function reserve_wait (line 335) | void reserve_wait() override;
  type graph_iterator (line 373) | typedef graph_iterator<graph, graph_node> iterator;
  type graph_iterator (line 374) | typedef graph_iterator<const graph, const
  function const_iterator (line 382) | const_iterator begin() const;
  function exception_thrown (line 398) | bool exception_thrown() { return caught_exception; }
  function destruct_and_deallocate (line 436) | void graph_task::destruct_and_deallocate(const d1::execution_data& ed) {
  function finalize (line 444) | void graph_task::finalize(const d1::execution_data& ed) {
  function class (line 477) | class graph_node : no_copy {
  function activate_graph (line 504) | inline void activate_graph(graph& g) {
  function deactivate_graph (line 508) | inline void deactivate_graph(graph& g) {
  function is_graph_active (line 512) | inline bool is_graph_active(graph& g) {
  function is_this_thread_in_graph_arena (line 516) | inline bool is_this_thread_in_graph_arena(graph& g) {
  function graph_task (line 521) | inline graph_task* prioritize_task(graph& g, graph_task& gt) {
  function spawn_in_graph_arena (line 541) | inline void spawn_in_graph_arena(graph& g, graph_task& arena_task) {
  function enqueue_in_graph_arena (line 559) | inline void enqueue_in_graph_arena(graph &g, graph_task& arena_task) {

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_indexer_impl.h
  function set_indexer_node_pointer (line 42) | inline void set_indexer_node_pointer(PortTuple &my_input, IndexerNodeBas...
  function set_indexer_node_pointer (line 53) | inline void set_indexer_node_pointer(PortTuple &my_input, IndexerNodeBas...
  type graph_task (line 64) | typedef graph_task* (* forward_function_ptr)(T const &, void*
  function graph_task (line 79) | graph_task* try_put_task(const T &v) override {
  function graph_task (line 84) | graph_task* try_put_task(const T& v, const message_metainfo& metainfo) o...
  function override (line 89) | const override {
  type OutputType (line 98) | typedef OutputType output_type;
  type InputTuple (line 99) | typedef InputTuple input_type;
  type OutputType (line 117) | typedef OutputType output_type;
  type StructTypes (line 118) | typedef StructTypes tuple_types;
  type typename (line 119) | typedef typename sender<output_type>::successor_type successor_type;
  type indexer_node_FE (line 120) | typedef indexer_node_FE<InputTuple, output_type,StructTypes> input_ports...
  type op_type (line 124) | enum op_type { reg_succ, rem_succ, try__put_task
  type indexer_node_base (line 126) | typedef indexer_node_base<InputTuple,output_type,StructTypes> class_type;
  function class (line 128) | class indexer_node_base_operation : public d1::aggregated_operation<inde...
  function register_successor (line 193) | bool register_successor(successor_type &r) override {
  function remove_successor (line 199) | bool remove_successor( successor_type &r) override {
  function graph_task (line 206) | graph_task* try_put_task(output_type const *v
  type tagged_msg (line 231) | typedef tagged_msg<size_t, first_type > type;
  type tagged_msg (line 238) | typedef tagged_msg<size_t, first_type, second_type> type;
  type tagged_msg (line 246) | typedef tagged_msg<size_t, first_type, second_type, third_type> type;
  type tagged_msg (line 255) | typedef tagged_msg<size_t, first_type, second_type, third_type,
  type tagged_msg (line 266) | typedef tagged_msg<size_t, first_type, second_type, third_type,
  type tagged_msg (line 278) | typedef tagged_msg<size_t, first_type, second_type, third_type,
  type tagged_msg (line 291) | typedef tagged_msg<size_t, first_type, second_type, third_type,
  type tagged_msg (line 307) | typedef tagged_msg<size_t, first_type, second_type, third_type,
  type tagged_msg (line 324) | typedef tagged_msg<size_t, first_type, second_type, third_type,
  type tagged_msg (line 341) | typedef tagged_msg<size_t, first_type, second_type, third_type,
  type typename (line 351) | typedef typename input_types<N, OutputTuple>::type output_type;
  type typename (line 352) | typedef typename wrap_tuple_elements<N,indexer_input_port,OutputTuple>::...
  type indexer_node_FE (line 353) | typedef indexer_node_FE<input_ports_type,output_type,OutputTuple> indexe...
  type indexer_node_base (line 354) | typedef indexer_node_base<input_ports_type, output_type, OutputTuple> in...
  type OutputTuple (line 361) | typedef OutputTuple tuple_types;
  type typename (line 362) | typedef typename indexer_types<OutputTuple>::output_type output_type;
  function base_type (line 367) | unfolded_indexer_node(const unfolded_indexer_node &other) : base_type(ot...

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_item_buffer_impl.h
  type buffer_item_state (line 38) | enum buffer_item_state { no_item=0, has_item=1, reserved_item=2 }
  type aligned_space_item (line 40) | struct aligned_space_item {
  type size_type (line 47) | typedef size_t size_type;
  type aligned_space (line 48) | typedef aligned_space<aligned_space_item> buffer_item_type;
  type typename (line 49) | typedef typename allocator_traits<A>::template rebind_alloc<buffer_item_...
  function aligned_space_item (line 67) | const aligned_space_item &element(size_type i) const {
  function my_item_valid (line 76) | bool my_item_valid(size_type i) const { return (i < my_tail) && (i >= my...
  function my_item_reserved (line 78) | bool my_item_reserved(size_type i) const { return element(i).state == re...
  function item_type (line 82) | const item_type &get_my_item(size_t i) const {
  function set_my_item (line 95) | void set_my_item(size_t i, const item_type &o
  function set_my_item (line 113) | void set_my_item(size_t i, const item_type& o, message_metainfo&& metain...
  function fetch_item (line 128) | void fetch_item(size_t i, item_type& o, message_metainfo& metainfo) {
  function fetch_item (line 135) | void fetch_item(size_t i, item_type &o) {
  function move_item (line 145) | void move_item(size_t to, size_t from) {
  function place_item (line 164) | bool place_item(size_t here, const item_type &me) {
  function swap_items (line 174) | void swap_items(size_t i, size_t j) {
  function destroy_item (line 187) | void destroy_item(size_type i) {
  function reserve_item (line 233) | void reserve_item(size_type i) {
  function release_item (line 238) | void release_item(size_type i) {
  function destroy_front (line 243) | void destroy_front() { destroy_item(my_head); ++my_head; }
  function destroy_back (line 244) | void destroy_back() { destroy_item(my_tail-1); --my_tail; }
  function size_type (line 249) | size_type capacity() { return my_array_size; }
  function buffer_full (line 252) | bool buffer_full() { return size() >= capacity(); }
  function grow_my_array (line 255) | void grow_my_array( size_t minimum_size ) {
  function push_back (line 286) | bool push_back(item_type& v
  function pop_back (line 297) | bool pop_back(item_type& v
  function pop_front (line 313) | bool pop_front(item_type& v
  function pop_back (line 330) | bool pop_back(item_type& v) {
  function pop_front (line 335) | bool pop_front(item_type& v) {
  function clean_up_buffer (line 343) | void clean_up_buffer(bool reset_pointers) {
  function reset (line 368) | void reset() { clean_up_buffer(/*reset_pointers*/true); grow_my_array(in...
  function reset (line 383) | void reset() {my_reserved = false; item_buffer<T,A>::reset(); }
  function reserve_front (line 396) | bool reserve_front(T& v, message_metainfo& metainfo) {
  function consume_front (line 407) | void consume_front() {
  function release_front (line 413) | void release_front() {

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_join_impl.h
  function no_assign (line 26) | struct forwarding_base : no_assign {
  function forwarding_base (line 32) | struct queueing_forwarding_base : forwarding_base {
  function forwarding_base (line 39) | struct reserving_forwarding_base : forwarding_base {
  type typename (line 51) | typedef typename std::decay<KeyType>::type current_key_type;
  function forwarding_base (line 52) | forwarding_base(g) { }
  function set_join_node_pointer (line 61) | inline void set_join_node_pointer(TupleType &my_input, PortType *port) {
  function consume_reservations (line 66) | inline void consume_reservations( TupleType &my_input ) {
  function release_my_reservation (line 72) | inline void release_my_reservation( TupleType &my_input ) {
  function release_reservations (line 77) | inline void release_reservations( TupleType &my_input) {
  function reserve (line 83) | inline bool reserve( InputTuple &my_input, OutputTuple &out) {
  function reserve (line 94) | inline bool reserve(InputTuple& my_input, OutputTuple& out, message_meta...
  function get_my_item (line 108) | inline bool get_my_item( InputTuple &my_input, OutputTuple &out) {
  function get_my_item (line 115) | inline bool get_my_item(InputTuple& my_input, OutputTuple& out, message_...
  function get_items (line 124) | inline bool get_items(InputTuple &my_input, OutputTuple &out) {
  function get_items (line 130) | inline bool get_items(InputTuple& my_input, OutputTuple& out, message_me...
  function reset_my_port (line 136) | inline void reset_my_port(InputTuple &my_input) {
  function reset_ports (line 142) | inline void reset_ports(InputTuple& my_input) {
  function set_key_functors (line 147) | inline void set_key_functors(InputTuple &my_input, KeyFuncTuple &my_key_...
  function copy_key_functors (line 154) | inline void copy_key_functors(KeyFuncTuple &my_inputs, KeyFuncTuple &oth...
  function reset_inputs (line 164) | inline void reset_inputs(InputTuple &my_input, reset_flags f) {
  type join_helper (line 171) | struct join_helper
  function set_join_node_pointer (line 174) | inline void set_join_node_pointer(TupleType &my_input, PortType *port) {
  function consume_reservations (line 179) | inline void consume_reservations( TupleType &my_input ) {
  function release_my_reservation (line 184) | inline void release_my_reservation( TupleType &my_input ) {
  function release_reservations (line 189) | inline void release_reservations( TupleType &my_input) {
  function reserve (line 194) | inline bool reserve( InputTuple &my_input, OutputTuple &out) {
  function reserve (line 200) | inline bool reserve(InputTuple& my_input, OutputTuple& out, message_meta...
  function get_my_item (line 209) | inline bool get_my_item( InputTuple &my_input, OutputTuple &out) {
  function get_my_item (line 215) | inline bool get_my_item(InputTuple& my_input, OutputTuple& out, message_...
  function get_items (line 224) | inline bool get_items(InputTuple &my_input, OutputTuple &out) {
  function get_items (line 230) | inline bool get_items(InputTuple& my_input, OutputTuple& out, message_me...
  function reset_my_port (line 236) | inline void reset_my_port(InputTuple &my_input) {
  function reset_ports (line 241) | inline void reset_ports(InputTuple& my_input) {
  function set_key_functors (line 246) | inline void set_key_functors(InputTuple &my_input, KeyFuncTuple &my_key_...
  function copy_key_functors (line 252) | inline void copy_key_functors(KeyFuncTuple &my_inputs, KeyFuncTuple &oth...
  function reset_inputs (line 260) | inline void reset_inputs(InputTuple &my_input, reset_flags f) {
  type typename (line 270) | typedef typename receiver<input_type>::predecessor_type predecessor_type;
  type op_type (line 274) | enum op_type { reg_pred, rem_pred, res_item, rel_res, con_res
  type reserving_port (line 276) | typedef reserving_port<T> class_type;
  function class (line 278) | class reserving_port_operation : public d1::aggregated_operation<reservi...
  type d1 (line 300) | typedef d1::aggregating_functor<class_type, reserving_port_operation> ha...
  function handle_operations (line 304) | void handle_operations(reserving_port_operation* op_list) {
  function graph_task (line 372) | graph_task* try_put_task( const T & ) override {
  function graph_task (line 377) | graph_task* try_put_task(const T&, const message_metainfo&) override { r...
  function override (line 380) | const override {
  function set_join_node_pointer (line 394) | void set_join_node_pointer(reserving_forwarding_base *join) {
  function register_predecessor (line 399) | bool register_predecessor( predecessor_type &src ) override {
  function remove_predecessor (line 406) | bool remove_predecessor( predecessor_type &src ) override {
  function reserve (line 413) | bool reserve( T &v ) {
  function reserve (line 420) | bool reserve( T& v, message_metainfo& metainfo ) {
  function release (line 428) | void release( ) {
  function consume (line 434) | void consume( ) {
  function reset_receiver (line 439) | void reset_receiver( reset_flags f) {
  type typename (line 462) | typedef typename receiver<input_type>::predecessor_type predecessor_type;
  type queueing_port (line 463) | typedef queueing_port<T> class_type;
  type op_type (line 467) | enum op_type { get__item, res_port, try__put_task
  function class (line 470) | class queueing_port_operation : public d1::aggregated_operation<queueing...
  type count_element (line 649) | typedef count_element<K> table_item_type;
  function K (line 650) | const K& operator()(const table_item_type& v) { return v.my_key; }
  type key_matching_port (line 672) | typedef key_matching_port<traits> class_type;
  type typename (line 673) | typedef typename TraitsType::T input_type;
  type typename (line 674) | typedef typename TraitsType::K key_type;
  type typename (line 675) | typedef typename std::decay<key_type>::type noref_key_type;
  type typename (line 676) | typedef typename receiver<input_type>::predecessor_type predecessor_type;
  type typename (line 677) | typedef typename TraitsType::TtoK type_to_key_func_type;
  type typename (line 678) | typedef typename TraitsType::KHash hash_compare_type;
  type typename (line 679) | typedef typename key_matching_port_base<key_type, input_type, type_to_ke...
  type op_type (line 684) | enum op_type { try__put, get__item, res_port
  function class (line 687) | class key_matching_port_operation : public d1::aggregated_operation<key_...
  function graph_task (line 783) | graph_task* try_put_task(const input_type& v, const message_metainfo& me...
  function override (line 788) | const override {
  function set_join_node_pointer (line 808) | void set_join_node_pointer(forwarding_base *join) {
  function set_my_key_func (line 812) | void set_my_key_func(type_to_key_func_type *f) { this->set_key_func(f); }
  function type_to_key_func_type (line 814) | type_to_key_func_type* get_my_key_func() { return this->get_key_func(); }
  function get_item (line 816) | bool get_item( input_type &v ) {
  function get_item (line 824) | bool get_item( input_type& v, message_metainfo& metainfo ) {
  function reset_port (line 834) | void reset_port() {
  function reset_receiver (line 840) | void reset_receiver(reset_flags ) {
  type OutputTuple (line 863) | typedef OutputTuple output_type;
  type InputTuple (line 864) | typedef InputTuple input_type;
  type join_node_base (line 865) | typedef join_node_base<reserving, InputTuple, OutputTuple> base_node_type;
  function set_my_node (line 877) | void set_my_node(base_node_type *new_my_node) { my_node = new_my_node; }
  function increment_port_count (line 879) | void increment_port_count() override {
  function graph_task (line 884) | graph_task* decrement_port_count() override {
  function tuple_build_may_succeed (line 908) | bool tuple_build_may_succeed() {
  function try_to_make_tuple (line 912) | bool try_to_make_tuple(output_type &out) {
  function try_to_make_tuple (line 918) | bool try_to_make_tuple(output_type &out, message_metainfo& metainfo) {
  function tuple_accepted (line 924) | void tuple_accepted() {
  function tuple_rejected (line 927) | void tuple_rejected() {
  type OutputTuple (line 940) | typedef OutputTuple output_type;
  type InputTuple (line 941) | typedef InputTuple input_type;
  type join_node_base (line 942) | typedef join_node_base<queueing, InputTuple, OutputTuple> base_node_type;
  function set_my_node (line 955) | void set_my_node(base_node_type *new_my_node) { my_node = new_my_node; }
  function reset_port_count (line 957) | void reset_port_count() {
  function graph_task (line 962) | graph_task* decrement_port_count(bool handle_task) override
  function tuple_build_may_succeed (line 988) | bool tuple_build_may_succeed() {
  function try_to_make_tuple (line 992) | bool try_to_make_tuple(output_type &out) {
  function try_to_make_tuple (line 998) | bool try_to_make_tuple(output_type &out, message_metainfo& metainfo) {
  function tuple_accepted (line 1004) | void tuple_accepted() {
  function tuple_rejected (line 1008) | void tuple_rejected() {
  type OutputTuple (line 1032) | typedef OutputTuple output_type;
  type InputTuple (line 1033) | typedef InputTuple input_type;
  type K (line 1034) | typedef K key_type;
  type typename (line 1035) | typedef typename std::decay<key_type>::type unref_key_type;
  type KHash (line 1036) | typedef KHash key_hash_compare;
  type count_element (line 1038) | typedef count_element<unref_key_type> count_element_type;
  type key_to_count_functor (line 1040) | typedef key_to_count_functor<unref_key_type> key_to_count_func;
  type type_to_key_function_body (line 1041) | typedef type_to_key_function_body< count_element_type, unref_key_type&> ...
  type type_to_key_function_body_leaf (line 1042) | typedef type_to_key_function_body_leaf<count_element_type, unref_key_typ...
  type hash_buffer (line 1045) | typedef hash_buffer< unref_key_type&, count_element_type, TtoK_function_...
  type item_buffer (line 1047) | typedef item_buffer<output_type> output_buffer_type;
  type join_node_base (line 1048) | typedef join_node_base<key_matching<key_type,key_hash_compare>, InputTup...
  type matching_forwarding_base (line 1049) | typedef matching_forwarding_base<key_type> forwarding_base_type;
  type op_type (line 1055) | enum op_type { res_count, inc_count, may_succeed, try_make }
  type join_node_FE (line 1056) | typedef join_node_FE<key_matching<key_type,key_hash_compare>, InputTuple...
  function class (line 1058) | class key_matching_FE_operation : public d1::aggregated_operation<key_ma...
  function set_my_node (line 1184) | void set_my_node(base_node_type *new_my_node) { my_node = new_my_node; }
  function reset_port_count (line 1186) | void reset_port_count() {  // called from BE
  function graph_task (line 1194) | graph_task *increment_key_count(unref_key_type const & t) override {  //...
  function tuple_build_may_succeed (line 1214) | bool tuple_build_may_succeed() {  // called from back-end
  function try_to_make_tuple (line 1222) | bool try_to_make_tuple(output_type &out) {
  function try_to_make_tuple (line 1229) | bool try_to_make_tuple(output_type &out, message_metainfo& metainfo) {
  function tuple_accepted (line 1236) | void tuple_accepted() {
  function tuple_rejected (line 1240) | void tuple_rejected() {
  type typename (line 1257) | typedef typename sender<output_type>::successor_type successor_type;
  type join_node_FE (line 1258) | typedef join_node_FE<JP, InputTuple, OutputTuple> input_ports_type;
  type op_type (line 1266) | enum op_type { reg_succ, rem_succ, try__get, do_fwrd, do_fwrd_bypass
  type join_node_base (line 1268) | typedef join_node_base<JP,InputTuple,OutputTuple> class_type;
  function class (line 1270) | class join_node_base_operation : public d1::aggregated_operation<join_no...
  type d1 (line 1293) | typedef d1::aggregating_functor<class_type, join_node_base_operation> ha...
  function handle_operations (line 1298) | void handle_operations(join_node_base_operation* op_list) {
  type join_node_base (line 1461) | typedef join_node_base<JP, typename
  type K (line 1467) | typedef K key_type;
  type KHash (line 1468) | typedef KHash key_hash_compare;
  type join_node_base (line 1469) | typedef join_node_base< key_traits_type,
  type OutputTuple (line 1483) | typedef OutputTuple output_type;
  function base_type (line 1488) | unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
  function K (line 1494) | K operator()(const T& t) const {
  type OutputTuple (line 1516) | typedef OutputTuple output_type;
  type type_to_key_function_body (line 1519) | typedef type_to_key_function_body<T0, K> *f0_p;
  type type_to_key_function_body (line 1520) | typedef type_to_key_function_body<T1, K> *f1_p;
  type std (line 1521) | typedef std::tuple< f0_p, f1_p > func_initializer_type;
  function base_type (line 1539) | unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
  type OutputTuple (line 1550) | typedef OutputTuple output_type;
  type type_to_key_function_body (line 1553) | typedef type_to_key_function_body<T0, K> *f0_p;
  type type_to_key_function_body (line 1554) | typedef type_to_key_function_body<T1, K> *f1_p;
  type type_to_key_function_body (line 1555) | typedef type_to_key_function_body<T2, K> *f2_p;
  type std (line 1556) | typedef std::tuple< f0_p, f1_p, f2_p > func_initializer_type;
  function base_type (line 1576) | unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
  type OutputTuple (line 1588) | typedef OutputTuple output_type;
  type type_to_key_function_body (line 1591) | typedef type_to_key_function_body<T0, K> *f0_p;
  type type_to_key_function_body (line 1592) | typedef type_to_key_function_body<T1, K> *f1_p;
  type type_to_key_function_body (line 1593) | typedef type_to_key_function_body<T2, K> *f2_p;
  type type_to_key_function_body (line 1594) | typedef type_to_key_function_body<T3, K> *f3_p;
  type std (line 1595) | typedef std::tuple< f0_p, f1_p, f2_p, f3_p > func_initializer_type;
  function base_type (line 1617) | unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
  type OutputTuple (line 1630) | typedef OutputTuple output_type;
  type type_to_key_function_body (line 1633) | typedef type_to_key_function_body<T0, K> *f0_p;
  type type_to_key_function_body (line 1634) | typedef type_to_key_function_body<T1, K> *f1_p;
  type type_to_key_function_body (line 1635) | typedef type_to_key_function_body<T2, K> *f2_p;
  type type_to_key_function_body (line 1636) | typedef type_to_key_function_body<T3, K> *f3_p;
  type type_to_key_function_body (line 1637) | typedef type_to_key_function_body<T4, K> *f4_p;
  type std (line 1638) | typedef std::tuple< f0_p, f1_p, f2_p, f3_p, f4_p > func_initializer_type;
  function base_type (line 1662) | unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
  type OutputTuple (line 1677) | typedef OutputTuple output_type;
  type type_to_key_function_body (line 1680) | typedef type_to_key_function_body<T0, K> *f0_p;
  type type_to_key_function_body (line 1681) | typedef type_to_key_function_body<T1, K> *f1_p;
  type type_to_key_function_body (line 1682) | typedef type_to_key_function_body<T2, K> *f2_p;
  type type_to_key_function_body (line 1683) | typedef type_to_key_function_body<T3, K> *f3_p;
  type type_to_key_function_body (line 1684) | typedef type_to_key_function_body<T4, K> *f4_p;
  type type_to_key_function_body (line 1685) | typedef type_to_key_function_body<T5, K> *f5_p;
  type std (line 1686) | typedef std::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p > func_initialize...
  function base_type (line 1712) | unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
  type OutputTuple (line 1729) | typedef OutputTuple output_type;
  type type_to_key_function_body (line 1732) | typedef type_to_key_function_body<T0, K> *f0_p;
  type type_to_key_function_body (line 1733) | typedef type_to_key_function_body<T1, K> *f1_p;
  type type_to_key_function_body (line 1734) | typedef type_to_key_function_body<T2, K> *f2_p;
  type type_to_key_function_body (line 1735) | typedef type_to_key_function_body<T3, K> *f3_p;
  type type_to_key_function_body (line 1736) | typedef type_to_key_function_body<T4, K> *f4_p;
  type type_to_key_function_body (line 1737) | typedef type_to_key_function_body<T5, K> *f5_p;
  type type_to_key_function_body (line 1738) | typedef type_to_key_function_body<T6, K> *f6_p;
  type std (line 1739) | typedef std::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p > func_init...
  function base_type (line 1768) | unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
  type OutputTuple (line 1786) | typedef OutputTuple output_type;
  type type_to_key_function_body (line 1789) | typedef type_to_key_function_body<T0, K> *f0_p;
  type type_to_key_function_body (line 1790) | typedef type_to_key_function_body<T1, K> *f1_p;
  type type_to_key_function_body (line 1791) | typedef type_to_key_function_body<T2, K> *f2_p;
  type type_to_key_function_body (line 1792) | typedef type_to_key_function_body<T3, K> *f3_p;
  type type_to_key_function_body (line 1793) | typedef type_to_key_function_body<T4, K> *f4_p;
  type type_to_key_function_body (line 1794) | typedef type_to_key_function_body<T5, K> *f5_p;
  type type_to_key_function_body (line 1795) | typedef type_to_key_function_body<T6, K> *f6_p;
  type type_to_key_function_body (line 1796) | typedef type_to_key_function_body<T7, K> *f7_p;
  type std (line 1797) | typedef std::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p, f7_p > fun...
  function base_type (line 1828) | unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
  type OutputTuple (line 1847) | typedef OutputTuple output_type;
  type type_to_key_function_body (line 1850) | typedef type_to_key_function_body<T0, K> *f0_p;
  type type_to_key_function_body (line 1851) | typedef type_to_key_function_body<T1, K> *f1_p;
  type type_to_key_function_body (line 1852) | typedef type_to_key_function_body<T2, K> *f2_p;
  type type_to_key_function_body (line 1853) | typedef type_to_key_function_body<T3, K> *f3_p;
  type type_to_key_function_body (line 1854) | typedef type_to_key_function_body<T4, K> *f4_p;
  type type_to_key_function_body (line 1855) | typedef type_to_key_function_body<T5, K> *f5_p;
  type type_to_key_function_body (line 1856) | typedef type_to_key_function_body<T6, K> *f6_p;
  type type_to_key_function_body (line 1857) | typedef type_to_key_function_body<T7, K> *f7_p;
  type type_to_key_function_body (line 1858) | typedef type_to_key_function_body<T8, K> *f8_p;
  type std (line 1859) | typedef std::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p, f7_p, f8_p...
  function base_type (line 1892) | unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
  type OutputTuple (line 1912) | typedef OutputTuple output_type;
  type type_to_key_function_body (line 1915) | typedef type_to_key_function_body<T0, K> *f0_p;
  type type_to_key_function_body (line 1916) | typedef type_to_key_function_body<T1, K> *f1_p;
  type type_to_key_function_body (line 1917) | typedef type_to_key_function_body<T2, K> *f2_p;
  type type_to_key_function_body (line 1918) | typedef type_to_key_function_body<T3, K> *f3_p;
  type type_to_key_function_body (line 1919) | typedef type_to_key_function_body<T4, K> *f4_p;
  type type_to_key_function_body (line 1920) | typedef type_to_key_function_body<T5, K> *f5_p;
  type type_to_key_function_body (line 1921) | typedef type_to_key_function_body<T6, K> *f6_p;
  type type_to_key_function_body (line 1922) | typedef type_to_key_function_body<T7, K> *f7_p;
  type type_to_key_function_body (line 1923) | typedef type_to_key_function_body<T8, K> *f8_p;
  type type_to_key_function_body (line 1924) | typedef type_to_key_function_body<T9, K> *f9_p;
  type std (line 1925) | typedef std::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p, f7_p, f8_p...
  function base_type (line 1960) | unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_node_impl.h
  function pop (line 43) | void pop() {
  function push (line 47) | bool push( T& t ) {
  function push (line 52) | bool push( T& t, const message_metainfo& metainfo ) {
  type op_type (line 63) | enum op_type {reg_pred, rem_pred, try_fwd, tryput_bypass, app_body_bypas...
  type function_input_base (line 65) | typedef function_input_base<Input, Policy, A, ImplType> class_type;
  type typename (line 71) | typedef typename receiver<input_type>::predecessor_type predecessor_type;
  type predecessor_cache (line 72) | typedef predecessor_cache<input_type, null_mutex > predecessor_cache_type;
  type function_input_queue (line 73) | typedef function_input_queue<input_type, A> input_queue_type;
  type typename (line 74) | typedef typename allocator_traits<A>::template rebind_alloc<input_queue_...
  function function_input_base (line 89) | function_input_base( const function_input_base& src )
  function virtual (line 96) | virtual ~function_input_base() {
  function graph_task (line 101) | graph_task* try_put_task( const input_type& t) override {
  function graph_task (line 106) | graph_task* try_put_task( const input_type& t, const message_metainfo& m...
  function register_predecessor (line 112) | bool register_predecessor( predecessor_type &src ) override {
  function remove_predecessor (line 120) | bool remove_predecessor( predecessor_type &src ) override {
  function reset_receiver (line 146) | void reset_receiver( reset_flags f) {
  function override (line 153) | const override {
  function graph_task (line 157) | graph_task* try_get_postponed_task(const input_type& i) {
  type d1 (line 197) | typedef d1::aggregating_functor<class_type, operation_type> handler_type;
  function graph_task (line 201) | graph_task* perform_queued_requests() {
  function handle_operations (line 226) | void handle_operations(operation_type *op_list) {
  function internal_try_put_task (line 268) | void internal_try_put_task(operation_type *op) {
  function internal_forward (line 288) | void internal_forward(operation_type *op) {
  function graph_task (line 300) | graph_task* internal_try_put_bypass( const input_type& t
  function graph_task (line 311) | graph_task* try_put_task_base(const input_type& t
  function graph_task (line 322) | graph_task* try_put_task_impl( const input_type& t, /*lightweight=*/std:...
  function graph_task (line 337) | graph_task* try_put_task_impl( const input_type& t, /*lightweight=*/std:...
  function graph_task (line 349) | graph_task* apply_body_bypass( const input_type &i
  function graph_task (line 361) | graph_task* create_body_task( const input_type &input )
  function graph_task (line 384) | graph_task* forward_task() {
  function graph_task (line 399) | inline graph_task* create_forward_task() {
  function spawn_forward_task (line 410) | inline void spawn_forward_task() {
  type Input (line 425) | typedef Input input_type;
  type Output (line 426) | typedef Output output_type;
  type function_body (line 427) | typedef function_body<input_type, output_type> function_body_type;
  type function_input (line 428) | typedef function_input<Input, Output, Policy,A> my_class;
  type function_input_base (line 429) | typedef function_input_base<Input, Policy, A, my_class> base_type;
  type function_input_queue (line 430) | typedef function_input_queue<input_type, A> input_queue_type;
  function output_type (line 463) | output_type apply_body_impl( const input_type& i) {
  function graph_task (line 473) | graph_task* apply_body_impl_bypass( const input_type &i
  type clear_element (line 538) | struct clear_element
  type Input (line 563) | typedef Input input_type;
  type OutputPortSet (line 564) | typedef OutputPortSet output_ports_type;
  type multifunction_body (line 565) | typedef multifunction_body<input_type, output_ports_type> multifunction_...
  type multifunction_input (line 566) | typedef multifunction_input<Input, OutputPortSet, Policy, A> my_class;
  type function_input_base (line 567) | typedef function_input_base<Input, Policy, A, my_class> base_type;
  type function_input_queue (line 568) | typedef function_input_queue<input_type, A> input_queue_type;
  function graph_task (line 601) | graph_task* apply_body_impl_bypass( const input_type &i
  function check_task_and_spawn (line 641) | inline void check_task_and_spawn(graph& g, graph_task* t) {
  type emit_element (line 672) | struct emit_element
  type Output (line 701) | typedef Output output_type;
  type function_body (line 702) | typedef function_body<input_type, output_type> function_body_type;
  type continue_input (line 703) | typedef continue_input<output_type, Policy> class_type;
  function reset_receiver (line 738) | void reset_receiver( reset_flags f) override {
  function graph_task (line 761) | graph_task* apply_body_bypass( input_type __TBB_FLOW_GRAPH_METAINFO_ARG(...
  function graph_task (line 771) | graph_task* execute(const message_metainfo& metainfo) override {
  type clear_element (line 815) | struct clear_element
  type Output (line 816) | typedef Output output_type;
  type typename (line 817) | typedef typename sender<output_type>::successor_type successor_type;
  type broadcast_cache (line 818) | typedef broadcast_cache<output_type> broadcast_cache_type;
  function register_successor (line 824) | bool register_successor( successor_type &r ) override {
  function remove_successor (line 830) | bool remove_successor( successor_type &r ) override {
  type function_output (line 847) | typedef function_output<output_type> base_type;
  function base_type (line 850) | base_type(g) {}
  function base_type (line 851) | multifunction_output(const multifunction_output& other) : base_type(othe...
  function try_put (line 853) | bool try_put(const output_type &i) {
  function graph_task (line 873) | graph_task* try_put_task(const output_type& i, const message_metainfo& m...
  type emit_element (line 878) | struct emit_element

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_node_set_impl.h
  function namespace (line 32) | namespace order {
  function class (line 38) | class get_graph_helper {
  type Order (line 62) | typedef Order order_type;
  function namespace (line 75) | namespace alias_helpers {
  function decltype (line 169) | static auto get(NodeType& node) -> decltype(get_impl(node, has_input_por...
  function decltype (line 190) | static auto get_impl(NodeType& node, std::false_type) -> decltype(intern...
  function decltype (line 204) | static auto get(NodeType& node) -> decltype(get_impl(node, is_async_node...
  type make_edges_helper (line 228) | struct make_edges_helper

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_nodes_deduction.h
  type NoInputBody (line 32) | struct NoInputBody {}

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_tagged_buffer_impl.h
  function value_type (line 39) | value_type* get_value_ptr() { return reinterpret_cast<value_type*>(this-...
  function hash_buffer_element (line 40) | hash_buffer_element* get_next() { return reinterpret_cast<hash_buffer_el...
  function set_next (line 41) | void set_next(hash_buffer_element* new_next) { this->second = reinterpre...
  function create_element (line 43) | void create_element(const value_type& v) {
  function create_element (line 47) | void create_element(hash_buffer_element&& other) {
  function destroy_element (line 51) | void destroy_element() {
  function value_type (line 62) | value_type* get_value_ptr() { return reinterpret_cast<value_type*>(this-...
  function metainfo_hash_buffer_element (line 63) | metainfo_hash_buffer_element* get_next() {
  function set_next (line 66) | void set_next(metainfo_hash_buffer_element* new_next) { this->second = r...
  function create_element (line 69) | void create_element(const value_type& v, const message_metainfo& metainf...
  function create_element (line 79) | void create_element(metainfo_hash_buffer_element&& other) {
  function destroy_element (line 85) | void destroy_element() {
  type metainfo_hash_buffer (line 360) | struct metainfo_hash_buffer

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_trace_impl.h
  function namespace (line 25) | namespace tbb {
  function fgt_node_desc (line 180) | void fgt_node_desc( const NodeType *node, const char *desc ) {
  function fgt_graph_desc (line 185) | static inline void fgt_graph_desc( const void *g, const char *desc ) {
  function fgt_body (line 190) | static inline void fgt_body( void *node, void *body ) {
  function fgt_multioutput_node (line 195) | inline void fgt_multioutput_node(void* codeptr, string_resource_index t,...
  function fgt_multioutput_node_with_body (line 202) | inline void fgt_multioutput_node_with_body( void* codeptr, string_resour...
  function fgt_multiinput_node (line 210) | inline void fgt_multiinput_node( void* codeptr, string_resource_index t,...
  function fgt_multiinput_multioutput_node (line 216) | static inline void fgt_multiinput_multioutput_node( void* codeptr, strin...
  function fgt_node (line 226) | static inline void fgt_node( void* codeptr, string_resource_index t, voi...
  function fgt_node_with_body (line 231) | static void fgt_node_with_body( void* codeptr, string_resource_index t, ...
  function fgt_node (line 237) | static inline void fgt_node( void* codeptr, string_resource_index t, voi...
  function fgt_node_with_body (line 242) | static inline void  fgt_node_with_body( void* codeptr, string_resource_i...
  function fgt_node (line 248) | static inline void  fgt_node( void* codeptr, string_resource_index t, vo...
  function fgt_make_edge (line 253) | static inline void fgt_make_edge( void *output_port, void *input_port ) {
  function fgt_remove_edge (line 257) | static inline void fgt_remove_edge( void *output_port, void *input_port ) {
  function fgt_graph (line 261) | static inline void fgt_graph( void *g ) {
  function fgt_begin_body (line 265) | static inline void fgt_begin_body( void *body ) {
  function fgt_end_body (line 269) | static inline void fgt_end_body( void * ) {
  function fgt_async_try_put_begin (line 273) | static inline void fgt_async_try_put_begin( void *node, void *port ) {
  function fgt_async_try_put_end (line 277) | static inline void fgt_async_try_put_end( void *, void * ) {
  function fgt_async_reserve (line 281) | static inline void fgt_async_reserve( void *node, void *graph ) {
  function fgt_async_commit (line 285) | static inline void fgt_async_commit( void *node, void * /*graph*/) {
  function fgt_reserve_wait (line 289) | static inline void fgt_reserve_wait( void *graph ) {
  function fgt_release_wait (line 293) | static inline void fgt_release_wait( void *graph ) {
  function fgt_alias_port (line 301) | static inline void fgt_alias_port(void * /*node*/, void * /*p*/, bool /*...
  function fgt_composite (line 303) | static inline void fgt_composite ( void* /*codeptr*/, void * /*node*/, v...
  function fgt_graph (line 305) | static inline void fgt_graph( void * /*g*/ ) { }
  function fgt_multioutput_node_desc (line 308) | inline void fgt_multioutput_node_desc( const NodeType * /*node*/, const ...
  function fgt_node_desc (line 311) | inline void fgt_node_desc( const NodeType * /*node*/, const char * /*des...
  function fgt_graph_desc (line 313) | static inline void fgt_graph_desc( const void * /*g*/, const char * /*de...
  function fgt_multioutput_node (line 316) | inline void fgt_multioutput_node( void* /*codeptr*/, string_resource_ind...
  function fgt_multioutput_node_with_body (line 319) | inline void fgt_multioutput_node_with_body( void* /*codeptr*/, string_re...
  function fgt_multiinput_node (line 322) | inline void fgt_multiinput_node( void* /*codeptr*/, string_resource_inde...
  function fgt_multiinput_multioutput_node (line 324) | static inline void fgt_multiinput_multioutput_node( void* /*codeptr*/, s...
  function fgt_node (line 326) | static inline void fgt_node( void* /*codeptr*/, string_resource_index /*...
  function fgt_node (line 327) | static inline void  fgt_node( void* /*codeptr*/, string_resource_index /...
  function fgt_node_with_body (line 329) | static inline void fgt_node_with_body( void* /*codeptr*/, string_resourc...
  function fgt_node_with_body (line 330) | static inline void fgt_node_with_body( void* /*codeptr*/, string_resourc...
  function fgt_make_edge (line 332) | static inline void fgt_make_edge( void * /*output_port*/, void * /*input...
  function fgt_remove_edge (line 333) | static inline void fgt_remove_edge( void * /*output_port*/, void * /*inp...
  function fgt_begin_body (line 335) | static inline void fgt_begin_body( void * /*body*/ ) { }
  function fgt_end_body (line 336) | static inline void fgt_end_body( void *  /*body*/) { }
  function fgt_async_try_put_begin (line 338) | static inline void fgt_async_try_put_begin( void * /*node*/, void * /*po...
  function fgt_async_try_put_end (line 339) | static inline void fgt_async_try_put_end( void * /*node*/ , void * /*por...
  function fgt_async_reserve (line 340) | static inline void fgt_async_reserve( void * /*node*/, void * /*graph*/ ...
  function fgt_async_commit (line 341) | static inline void fgt_async_commit( void * /*node*/, void * /*graph*/ )...
  function fgt_reserve_wait (line 342) | static inline void fgt_reserve_wait( void * /*graph*/ ) { }
  function fgt_release_wait (line 343) | static inline void fgt_release_wait( void * /*graph*/ ) { }
  function alias_port (line 350) | static void alias_port( void * /*node*/, PortsTuple & /*ports*/ ) { }
  function alias_port (line 355) | static void alias_port( void * /*node*/, PortsTuple & /*ports*/ ) { }

FILE: third-party/tbb/include/oneapi/tbb/detail/_flow_graph_types_impl.h
  type Kp (line 39) | typedef Kp K;
  type Tp (line 40) | typedef Tp T;
  type type_to_key_function_body (line 41) | typedef type_to_key_function_body<T,K> TtoK;
  type KHashp (line 42) | typedef KHashp KHash;
  type typename (line 56) | typedef typename std::tuple<PT<Args>... > type;
  type typename (line 61) | typedef typename KeyTraits::key_type K;
  type typename (line 62) | typedef typename KeyTraits::hash_compare_type KHash;
  type typename (line 63) | typedef typename std::tuple<PT<KeyTrait<K, KHash, Args> >... > type;
  type test_alignment (line 77) | typedef struct { char t; U    padded; } test_alignment;
  type default_constructed (line 128) | struct default_constructed { }
  type WrapperBase (line 135) | struct WrapperBase {
  type T (line 145) | typedef T value_type;
  type T (line 146) | typedef T* pointer_type;
  type _unwind_space (line 156) | struct _unwind_space {
  function CopyTo (line 167) | void CopyTo(void* newSpace) const override {
  type T (line 178) | typedef T value_type;
  type T (line 179) | typedef T* pointer_type;
  type T (line 181) | typedef T ArrayType[N];
  type _unwind_class (line 193) | struct _unwind_class {
  function explicit (line 223) | explicit Wrapper(const Wrapper& other) : WrapperBase() {
  function CopyTo (line 235) | void CopyTo(void* newSpace) const override {
  type typename (line 256) | typedef typename pick_one< (Selector<T1>::value > Selector<T2>::value), ...
  type typename (line 262) | typedef typename pick_tuple_max<N-1, Tuple, Selector>::type LeftMaxType;
  type typename (line 263) | typedef typename std::tuple_element<N
  type typename (line 264) | typedef typename pick_max<Selector, LeftMaxType, ThisType>::type type;
  type typename (line 274) | typedef typename std::tuple_element<N
  function construct (line 292) | static void construct(void *mySpace, const T& x) {
  function construct (line 298) | static void construct(void * /*mySpace*/, const T& x) {
  type tagged_null_type (line 311) | struct tagged_null_type {}
  type typename (line 338) | typedef typename pick_tuple_max<N, Tuple, alignment_of>::type AlignType;
  type typename (line 339) | typedef typename pick_tuple_max<N, Tuple, size_of>::type MaxSizeType;
  type aligned_space (line 342) | typedef aligned_space<AlignType, MaxNElements> SpaceType;
  function set_tag (line 401) | void set_tag(TagType const &index) {my_tag = index;}
  type op_stat (line 420) | enum op_stat { WAIT = 0, SUCCEEDED, FAILED }

FILE: third-party/tbb/include/oneapi/tbb/detail/_hash_compare.h
  function namespace (line 24) | namespace tbb {
  function namespace (line 91) | inline namespace d0 {
  function namespace (line 107) | namespace std {

FILE: third-party/tbb/include/oneapi/tbb/detail/_intrusive_list_node.h
  function namespace (line 20) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_machine.h
  function namespace (line 58) | inline namespace d0 {
  type cpu_ctl_env (line 242) | struct cpu_ctl_env {
  function namespace (line 319) | namespace r1 {
  function class (line 326) | class cpu_ctl_env {

FILE: third-party/tbb/include/oneapi/tbb/detail/_namespace_injection.h
  function namespace (line 20) | namespace tbb {}
  function namespace (line 22) | namespace oneapi {

FILE: third-party/tbb/include/oneapi/tbb/detail/_node_handle.h
  function namespace (line 23) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_pipeline_filters.h
  function namespace (line 29) | namespace detail {
  function finalize (line 247) | void finalize(void * input) override {
  function finalize (line 294) | void finalize(void* input) override {
  function class (line 317) | class filter_node_ptr {
  function class (line 335) | class filter_node {
  function filter_node_ptr (line 380) | inline filter_node_ptr::filter_node_ptr(filter_node * nd) : my_node(nd) {
  function filter_node_ptr (line 386) | inline filter_node_ptr::~filter_node_ptr() {
  function filter_node_ptr (line 392) | inline filter_node_ptr::filter_node_ptr(const filter_node_ptr & rhs) : m...
  function filter_node_ptr (line 398) | inline filter_node_ptr::filter_node_ptr(filter_node_ptr && rhs) : my_nod...
  function filter_node (line 428) | inline filter_node& filter_node_ptr::operator*() const{
  function base_filter (line 442) | base_filter* create_filter() const override {

FILE: third-party/tbb/include/oneapi/tbb/detail/_pipeline_filters_deduction.h
  function namespace (line 24) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_range_common.h
  function namespace (line 29) | inline namespace d0 {

FILE: third-party/tbb/include/oneapi/tbb/detail/_rtm_mutex.h
  function namespace (line 26) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_rtm_rw_mutex.h
  function namespace (line 26) | namespace tbb {
  function namespace (line 124) | namespace r1 {
  function namespace (line 143) | namespace d1 {

FILE: third-party/tbb/include/oneapi/tbb/detail/_scoped_lock.h
  function namespace (line 20) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_segment_table.h
  function namespace (line 36) | namespace tbb {
  function swap (line 141) | void swap( segment_table& other )
  function segment_type (line 153) | segment_type get_segment( segment_index_type index ) const {
  function value_type (line 161) | const value_type& operator[]( size_type index ) const {
  function enable_segment (line 173) | void enable_segment( segment_type& segment, segment_table_type table, se...
  function delete_segment (line 191) | void delete_segment( segment_index_type seg_index ) {
  function size_type (line 203) | size_type number_of_segments( segment_table_type table ) const {
  function size_type (line 221) | size_type find_last_allocated_segment( segment_table_type table ) const ...
  function reserve (line 233) | void reserve( size_type n ) {
  function clear (line 246) | void clear() {
  function clear_segments (line 253) | void clear_segments() {
  function destroy_and_deallocate_table (line 263) | void destroy_and_deallocate_table(segment_table_type table, size_type nu...
  function clear_table (line 271) | void clear_table() {
  function extend_table_if_necessary (line 281) | void extend_table_if_necessary(segment_table_type& table, size_type star...
  function segment_index_type (line 324) | static constexpr segment_index_type segment_index_of( size_type index ) {
  function size_type (line 329) | static constexpr size_type segment_base( size_type index ) {
  function size_type (line 334) | static constexpr size_type segment_size( size_type index ) {
  type copy_segment_body_type (line 344) | struct copy_segment_body_type {
  type move_segment_body_type (line 351) | struct move_segment_body_type {
  function internal_move (line 390) | void internal_move( segment_table&& other ) {
  function internal_move_construct_with_allocator (line 413) | void internal_move_construct_with_allocator( segment_table&& other, cons...
  function internal_move_construct_with_allocator (line 420) | void internal_move_construct_with_allocator( segment_table&& other, cons...
  function internal_move_assign (line 437) | void internal_move_assign( segment_table&& other, /*is_always_equal || P...
  function internal_move_assign (line 443) | void internal_move_assign( segment_table&& other, /*is_always_equal || P...
  function internal_swap (line 455) | void internal_swap( segment_table& other, /*is_always_equal || POCS = */...
  function internal_swap (line 463) | void internal_swap( segment_table& other, /*is_always_equal || POCS = */...
  function internal_swap_fields (line 469) | void internal_swap_fields( segment_table& other ) {
  function assign_first_block_if_necessary (line 545) | void assign_first_block_if_necessary(segment_index_type index) {
  function zero_table (line 552) | void zero_table( segment_table_type table, size_type count ) {

FILE: third-party/tbb/include/oneapi/tbb/detail/_small_object_pool.h
  function namespace (line 28) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_task.h
  function namespace (line 34) | namespace tbb {
  function class (line 193) | class reference_vertex : public wait_tree_vertex_interface {
  function task_group_context (line 226) | inline task_group_context* context(const execution_data& ed) {
  function slot_id (line 230) | inline slot_id original_slot(const execution_data& ed) {
  function slot_id (line 234) | inline slot_id affinity_slot(const execution_data& ed) {
  function slot_id (line 238) | inline slot_id execution_slot(const execution_data& ed) {
  function is_same_affinity (line 242) | inline bool is_same_affinity(const execution_data& ed) {
  function is_stolen (line 246) | inline bool is_stolen(const execution_data& ed) {
  function spawn (line 250) | inline void spawn(task& t, task_group_context& ctx) {
  function spawn (line 255) | inline void spawn(task& t, task_group_context& ctx, slot_id id) {
  function execute_and_wait (line 260) | inline void execute_and_wait(task& t, task_group_context& t_ctx, wait_co...
  function wait (line 266) | inline void wait(wait_context& wait_ctx, task_group_context& ctx) {
  function class (line 274) | class task_traits {
  function class (line 284) | class alignas(task_alignment) task : public task_traits {

FILE: third-party/tbb/include/oneapi/tbb/detail/_task_handle.h
  function namespace (line 27) | namespace tbb {
  function noexcept (line 111) | nullptr_t) noexcept {

FILE: third-party/tbb/include/oneapi/tbb/detail/_template_helpers.h
  function namespace (line 30) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/detail/_utils.h
  function namespace (line 29) | namespace tbb {
  function log2 (line 142) | uintptr_t log2(T in) {
  function is_power_of_two (line 160) | bool is_power_of_two( IntegerType arg ) {
  function is_power_of_two_at_least (line 170) | bool is_power_of_two_at_least(ArgIntegerType arg, DivisorIntegerType div...
  function ArgIntegerType (line 179) | ArgIntegerType modulo_power_of_two(ArgIntegerType arg, DivisorIntegerTyp...
  function is_aligned (line 186) | bool is_aligned(T* pointer, std::uintptr_t alignment) {
  function poison_pointer (line 198) | void poison_pointer(std::atomic<T*>& p) { p.store(reinterpret_cast<T*>(p...
  function is_poisoned (line 202) | bool is_poisoned( T* p ) { return p == reinterpret_cast<T*>(poisoned_ptr...
  function is_poisoned (line 205) | bool is_poisoned(const std::atomic<T*>& p) { return is_poisoned(p.load(s...
  function class (line 230) | class no_assign {
  function class (line 238) | class no_copy: no_assign {
  type class (line 252) | enum class
  function namespace (line 368) | namespace d1 {

FILE: third-party/tbb/include/oneapi/tbb/detail/_waitable_atomic.h
  function namespace (line 22) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/enumerable_thread_specific.h
  function namespace (line 52) | namespace tbb {
  function reference (line 587) | reference operator*() const {
  function pointer (line 595) | pointer operator->() const { return &operator*();}
  function advance_me (line 602) | void advance_me() {
  function construct (line 632) | void construct(void*where) {new(where) T();}
  function construct_by_default (line 633) | construct_by_default( int ) {}
  function construct (line 639) | void construct(void*where) {new(where) T(exemplar);}
  function exemplar (line 640) | construct_by_exemplar( const T& t ) : exemplar(t) {}
  function construct (line 647) | void construct(void* where) {new(where) T(f());}
  function construct (line 654) | void construct(void* where) {
  function class (line 664) | class callback_base {
  function callback_base (line 682) | callback_base* clone() const override {
  function destroy (line 686) | void destroy() override {
  function construct (line 692) | void construct(void* where) override {
  function U (line 718) | U* value() { return my_space.begin(); }
  function U (line 719) | U* value_committed() { is_built = true; return my_space.begin(); }
  function free_array (line 822) | void free_array( void* _ptr, std::size_t _size) override {
  function explicit (line 860) | explicit enumerable_thread_specific( const T& exemplar ) : my_construct_...
  function explicit (line 864) | explicit enumerable_thread_specific( T&& exemplar ) : my_construct_callb...
  function reference (line 886) | reference local() {
  function reference (line 892) | reference local(bool& exists)  {
  function iterator (line 904) | iterator begin() { return iterator( my_locals, 0 ); }
  function iterator (line 906) | iterator end() { return iterator(my_locals, my_locals.size() ); }
  function clear (line 921) | void clear() {
  function internal_swap (line 939) | void internal_swap(enumerable_thread_specific& other) {
  function iterator (line 1073) | iterator begin() { return iterator(*my_container) = my_begin; }
  function iterator (line 1074) | iterator end() { return iterator(*my_container) = my_end; }
  function size_type (line 1078) | size_type size() const {
  function namespace (line 1105) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/flow_graph.h
  function namespace (line 71) | namespace tbb {
  function namespace (line 166) | namespace d2 {
  function graph_task (line 175) | static inline graph_task* combine_tasks(graph& g, graph_task* left, grap...
  function class (line 192) | class message_metainfo {
  function merge (line 206) | void merge(const message_metainfo& other) {
  function try_put (line 295) | bool try_put( const T& t ) {
  function try_put_and_wait (line 301) | bool try_put_and_wait( const T& t ) {
  type sender (line 320) | typedef sender<T> predecessor_type;
  function virtual (line 332) | virtual bool is_continue_receiver() { return false; }
  function continue_msg (line 372) | continue_receiver( const continue_receiver& src ) : receiver<continue_ms...
  function register_predecessor (line 379) | bool register_predecessor( predecessor_type & ) override {
  function remove_predecessor (line 389) | bool remove_predecessor( predecessor_type & ) override {
  type continue_msg (line 396) | typedef continue_msg input_type;
  type receiver (line 399) | typedef receiver<input_type>::predecessor_type predecessor_type;
  function graph_task (line 447) | graph_task* try_put_task( const input_type& input, const message_metainf...
  function virtual (line 464) | virtual void reset_receiver( reset_flags f ) {
  function is_continue_receiver (line 480) | bool is_continue_receiver() override { return true; }

FILE: third-party/tbb/include/oneapi/tbb/flow_graph_abstractions.h
  function namespace (line 20) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/global_control.h
  function namespace (line 31) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/info.h
  function namespace (line 27) | namespace tbb {
  function namespace (line 109) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/memory_pool.h
  function namespace (line 38) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/mutex.h
  function namespace (line 27) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/null_mutex.h
  function namespace (line 24) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/null_rw_mutex.h
  function namespace (line 24) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/parallel_for.h
  function namespace (line 37) | inline namespace d0 {
  function const (line 192) | void operator()( const blocked_range<Index>& r ) const {

FILE: third-party/tbb/include/oneapi/tbb/parallel_for_each.h
  function namespace (line 34) | namespace tbb {
  function internal_add_copy_impl (line 174) | void internal_add_copy_impl(std::true_type, const Item& item) {
  function internal_add_copy_impl (line 182) | void internal_add_copy_impl(std::false_type, const Item&) {
  function internal_add_copy (line 186) | void internal_add_copy(const Item& item) override {
  function internal_add_move (line 190) | void internal_add_move(Item&& item) override {
  function finalize (line 219) | void finalize() {
  function finalize (line 279) | void finalize(const execution_data& ed) {
  function finalize (line 344) | void finalize(const execution_data& ed) {
  function const (line 395) | void operator()(tbb::blocked_range<std::size_t> range) const {
  function small_object_allocator (line 519) | small_object_allocator alloc{}
  function small_object_allocator (line 562) | small_object_allocator alloc{}

FILE: third-party/tbb/include/oneapi/tbb/parallel_invoke.h
  function namespace (line 33) | namespace tbb {
  function small_object_allocator (line 173) | small_object_allocator alloc{}
  function wait_context (line 183) | wait_context root_wait_ctx{0};
  function wait_context (line 192) | wait_context root_wait_ctx{0}
  function namespace (line 222) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/parallel_pipeline.h
  function namespace (line 29) | namespace tbb {
  function namespace (line 143) | inline namespace v1

FILE: third-party/tbb/include/oneapi/tbb/parallel_reduce.h
  function namespace (line 31) | namespace tbb {
  function join (line 242) | void join(task_group_context* context) {
  function run (line 281) | static void run(const Range& range, Body& body, Partitioner& partitioner...
  function run (line 291) | static void run(const Range& range, Body& body, Partitioner& partitioner) {
  function run_body (line 299) | void run_body( Range &r ) {
  function offer_work (line 303) | void offer_work(typename Partitioner::split_type& split_obj, execution_d...
  function small_object_allocator (line 309) | small_object_allocator alloc{}
  function spawn_self (line 322) | void spawn_self(execution_data& ed) {
  function join (line 396) | void join( lambda_reduce_body& rhs ) {

FILE: third-party/tbb/include/oneapi/tbb/parallel_scan.h
  function namespace (line 33) | namespace detail {
  function namespace (line 55) | inline namespace d0 {
  function namespace (line 81) | namespace d1 {
  function reverse_join (line 153) | void reverse_join( final_sum& a ) {
  function reverse_join (line 156) | void reverse_join( Body& body ) {
  function assign_to (line 159) | void assign_to( Body& body ) {
  function self_destroy (line 162) | void self_destroy(const execution_data& ed) {
  function sum_node (line 235) | sum_node* finalize(const execution_data& ed) {
  function self_destroy (line 268) | void self_destroy(const execution_data& ed) {
  type start_scan (line 272) | struct start_scan
  type finish_scan (line 275) | struct finish_scan
  function finish_scan (line 341) | finish_scan* finalize(const execution_data& ed) {
  function finish_pass1_type (line 369) | finish_pass1_type* release_parent() {
  function finish_pass1_type (line 383) | finish_pass1_type* finalize( const execution_data& ed ) {
  function wait_context (line 431) | wait_context w_ctx{1};
  function small_object_allocator (line 462) | small_object_allocator alloc{}
  function small_object_allocator (line 480) | small_object_allocator alloc{}
  function reverse_join (line 527) | void reverse_join( lambda_scan_body& a ) {
  function assign (line 531) | void assign( lambda_scan_body& b ) {

FILE: third-party/tbb/include/oneapi/tbb/parallel_sort.h
  function namespace (line 52) | namespace d1 {
  function const (line 148) | void operator()( const blocked_range<RandomAccessIterator>& range ) const {
  function const (line 169) | void operator()( const quick_sort_range<RandomAccessIterator,Compare>& r...

FILE: third-party/tbb/include/oneapi/tbb/partitioner.h
  function namespace (line 60) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/profiling.h
  function namespace (line 25) | namespace tbb {
  function namespace (line 65) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/queuing_mutex.h
  function class (line 35) | class queuing_mutex {

FILE: third-party/tbb/include/oneapi/tbb/queuing_rw_mutex.h
  function namespace (line 30) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/rw_mutex.h
  function namespace (line 27) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/scalable_allocator.h
  type ScalableAllocationResult (line 88) | typedef enum {
  type AllocationModeParam (line 98) | typedef enum {
  type ScalableAllocationCmd (line 114) | typedef enum {
  function namespace (line 135) | namespace rml {

FILE: third-party/tbb/include/oneapi/tbb/spin_mutex.h
  function namespace (line 31) | namespace tbb {
  function namespace (line 123) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/spin_rw_mutex.h
  function namespace (line 31) | namespace tbb {
  function namespace (line 218) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/task.h
  function namespace (line 24) | namespace tbb {

FILE: third-party/tbb/include/oneapi/tbb/task_arena.h
  function namespace (line 35) | namespace tbb {
  function namespace (line 606) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/task_group.h
  function namespace (line 41) | namespace tbb {
  function task_group_status (line 551) | task_group_status wait() {
  function cancel (line 563) | void cancel() {
  function class (line 568) | class task_group : public task_group_base {
  function task_group_status (line 598) | task_group_status run_and_wait(d2::task_handle&& h) {
  function class (line 604) | class spawn_delegate : public d1::delegate_base {
  function class (line 617) | class wait_delegate : public d1::delegate_base {
  function class (line 642) | class isolated_task_group : public task_group {
  function namespace (line 688) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/task_scheduler_observer.h
  function namespace (line 25) | namespace detail {

FILE: third-party/tbb/include/oneapi/tbb/tbb_allocator.h
  function namespace (line 29) | namespace tbb {
  function namespace (line 121) | inline namespace v1 {

FILE: third-party/tbb/include/oneapi/tbb/tbbmalloc_proxy.h
  type __TBB_malloc_proxy_caller (line 56) | struct __TBB_malloc_proxy_caller {

FILE: third-party/tbb/include/oneapi/tbb/tick_count.h
  function namespace (line 24) | namespace tbb {

FILE: third-party/tbb/python/rml/ipc_server.cpp
  type rml (line 33) | namespace rml {
    type internal (line 34) | namespace internal {
      function __RML_open_factory (line 40) | factory::status_type __RML_open_factory(factory& f, version_type& /*...
      function __RML_close_factory (line 62) | void __RML_close_factory(factory& /*f*/) {
      class ipc_thread_monitor (line 65) | class ipc_thread_monitor : public tbb::detail::r1::rml::internal::th...
        method ipc_thread_monitor (line 67) | ipc_thread_monitor() : thread_monitor() {}
  type r1 (line 98) | namespace r1 {
    function terminate_on_exception (line 99) | bool terminate_on_exception() {
  class ipc_server (line 108) | class ipc_server
    method propagate_chain_reaction (line 407) | void propagate_chain_reaction() {
    method remove_server_ref (line 451) | void remove_server_ref() {
    method version_type (line 466) | version_type version() const override {
    method request_close_connection (line 470) | void request_close_connection(bool /*exiting*/) override {
    method yield (line 478) | void yield() override {d0::yield();}
    method independent_thread_number_changed (line 480) | void independent_thread_number_changed(int) override { __TBB_ASSERT( f...
    method default_concurrency (line 482) | unsigned default_concurrency() const override { return my_n_thread - 1; }
    method register_external_thread (line 487) | void register_external_thread(::rml::server::execution_resource_t&) ov...
    method unregister_external_thread (line 488) | void unregister_external_thread(::rml::server::execution_resource_t) o...
  function release_thread_sem (line 149) | static void release_thread_sem(sem_t* my_sem) {
  function set_sem_name (line 159) | void set_sem_name(const char* name, const char* prefix) {
  function set_active_sem_name (line 180) | void set_active_sem_name() {
  function set_stop_sem_name (line 184) | void set_stop_sem_name() {
  function release_resources (line 188) | void release_resources() {
  function release_semaphores (line 201) | void release_semaphores() {
  class ipc_worker (line 238) | class ipc_worker: no_copy {
    type state_t (line 250) | enum state_t {
    method ipc_worker (line 303) | ipc_worker(ipc_server& server, tbb_client& client, const size_t i) :
  class padded_ipc_worker (line 320) | class padded_ipc_worker: public ipc_worker {
    method padded_ipc_worker (line 323) | padded_ipc_worker(ipc_server& server, tbb_client& client, const size_t i)
  class ipc_waker (line 330) | class ipc_waker : public padded_ipc_worker {
    method ipc_waker (line 339) | ipc_waker(ipc_server& server, tbb_client& client, const size_t i)
  class ipc_stopper (line 343) | class ipc_stopper : public padded_ipc_worker {
    method ipc_stopper (line 352) | ipc_stopper(ipc_server& server, tbb_client& client, const size_t i)
  class ipc_server (line 356) | class ipc_server: public tbb_server, no_copy {
    method propagate_chain_reaction (line 407) | void propagate_chain_reaction() {
    method remove_server_ref (line 451) | void remove_server_ref() {
    method version_type (line 466) | version_type version() const override {
    method request_close_connection (line 470) | void request_close_connection(bool /*exiting*/) override {
    method yield (line 478) | void yield() override {d0::yield();}
    method independent_thread_number_changed (line 480) | void independent_thread_number_changed(int) override { __TBB_ASSERT( f...
    method default_concurrency (line 482) | unsigned default_concurrency() const override { return my_n_thread - 1; }
    method register_external_thread (line 487) | void register_external_thread(::rml::server::execution_resource_t&) ov...
    method unregister_external_thread (line 488) | void unregister_external_thread(::rml::server::execution_resource_t) o...
  function __RML_DECL_THREAD_ROUTINE (line 502) | __attribute__((force_align_arg_pointer))
  function __RML_DECL_THREAD_ROUTINE (line 644) | __attribute__((force_align_arg_pointer))
  function __RML_DECL_THREAD_ROUTINE (line 743) | __attribute__((force_align_arg_pointer))
  type timespec (line 937) | struct timespec
  function rml_atexit (line 1099) | void rml_atexit() {
  function rml_atfork_child (line 1103) | void rml_atfork_child() {
  function __TBB_make_rml_server (line 1116) | tbb_factory::status_type __TBB_make_rml_server(tbb_factory& /*f*/, tbb_s...

FILE: third-party/tbb/python/rml/ipc_utils.cpp
  type tbb (line 25) | namespace tbb {
    type internal (line 26) | namespace internal {
      type rml (line 27) | namespace rml {
        function get_start_time (line 59) | unsigned long long get_start_time(int pid) {
        function get_num_threads (line 106) | int get_num_threads(const char* env_var) {
        function get_enable_flag (line 120) | bool get_enable_flag(const char* env_var) {

FILE: third-party/tbb/python/rml/ipc_utils.h
  function namespace (line 20) | namespace tbb {

FILE: third-party/tbb/python/setup.py
  class TBBBuild (line 77) | class TBBBuild(build):

FILE: third-party/tbb/python/tbb/__init__.py
  function _test (line 57) | def _test(arg=None):
  function tbb_process_pool_worker27 (line 68) | def tbb_process_pool_worker27(inqueue, outqueue, initializer=None, inita...
  class TBBProcessPool27 (line 80) | class TBBProcessPool27(multiprocessing.pool.Pool):
    method _repopulate_pool (line 81) | def _repopulate_pool(self):
    method __del__ (line 99) | def __del__(self):
    method __exit__ (line 104) | def __exit__(self, *args):
  function tbb_process_pool_worker3 (line 110) | def tbb_process_pool_worker3(inqueue, outqueue, initializer=None, initar...
  class TBBProcessPool3 (line 122) | class TBBProcessPool3(multiprocessing.pool.Pool):
    method _repopulate_pool (line 123) | def _repopulate_pool(self):
    method __del__ (line 142) | def __del__(self):
    method __exit__ (line 147) | def __exit__(self, *args):
  class Monkey (line 153) | class Monkey:
    method __init__ (line 169) | def __init__(self, max_num_threads=None, benchmark=False):
    method _patch (line 183) | def _patch(self, class_name, module_name, obj):
    method __enter__ (line 195) | def __enter__(self):
    method __exit__ (line 212) | def __exit__(self, exc_type, exc_value, traceback):
  function init_sem_name (line 228) | def init_sem_name():
  function tbb_atexit (line 238) | def tbb_atexit():
  function _main (line 248) | def _main():

FILE: third-party/tbb/python/tbb/pool.py
  class TimeoutError (line 79) | class TimeoutError(Exception):
  class Pool (line 84) | class Pool(object):
    method __init__ (line 90) | def __init__(self, nworkers=0, name="Pool"):
    method apply (line 99) | def apply(self, func, args=(), kwds=dict()):
    method map (line 104) | def map(self, func, iterable, chunksize=None):
    method imap (line 114) | def imap(self, func, iterable, chunksize=1):
    method imap_unordered (line 132) | def imap_unordered(self, func, iterable, chunksize=1):
    method apply_async (line 141) | def apply_async(self, func, args=(), kwds=dict(), callback=None):
    method map_async (line 156) | def map_async(self, func, iterable, chunksize=None, callback=None):
    method imap_async (line 171) | def imap_async(self, func, iterable, chunksize=None, callback=None):
    method imap_unordered_async (line 187) | def imap_unordered_async(self, func, iterable, chunksize=None,
    method close (line 204) | def close(self):
    method terminate (line 211) | def terminate(self):
    method join (line 218) | def join(self):
    method __enter__ (line 223) | def __enter__(self):
    method __exit__ (line 226) | def __exit__(self, exc_type, exc_value, traceback):
    method __del__ (line 229) | def __del__(self):
    method _create_sequences (line 233) | def _create_sequences(self, func, iterable, chunksize, collector):
  class Job (line 266) | class Job:
    method __init__ (line 269) | def __init__(self, func, args, kwds, apply_result):
    method __call__ (line 280) | def __call__(self):
  class JobSequence (line 294) | class JobSequence:
    method __init__ (line 298) | def __init__(self, jobs):
    method __call__ (line 301) | def __call__(self):
  class ApplyResult (line 309) | class ApplyResult(object):
    method __init__ (line 318) | def __init__(self, collector=None, callback=None):
    method get (line 337) | def get(self, timeout=None):
    method wait (line 350) | def wait(self, timeout=None):
    method ready (line 356) | def ready(self):
    method successful (line 360) | def successful(self):
    method _set_value (line 367) | def _set_value(self, value):
    method _set_exception (line 384) | def _set_exception(self):
  class AbstractResultCollector (line 398) | class AbstractResultCollector(object):
    method __init__ (line 405) | def __init__(self, to_notify):
    method register_result (line 412) | def register_result(self, apply_result):
    method notify_ready (line 421) | def notify_ready(self, apply_result):
    method _get_result (line 430) | def _get_result(self, idx, timeout=None):
    method __iter__ (line 441) | def __iter__(self):
  class CollectorIterator (line 446) | class CollectorIterator(object):
    method __init__ (line 452) | def __init__(self, collector):
    method __iter__ (line 457) | def __iter__(self):
    method next (line 460) | def next(self, timeout=None):
    method __next__ (line 477) | def __next__(self):
  class UnorderedResultCollector (line 481) | class UnorderedResultCollector(AbstractResultCollector):
    method __init__ (line 487) | def __init__(self, to_notify=None):
    method register_result (line 497) | def register_result(self, apply_result):
    method _get_result (line 506) | def _get_result(self, idx, timeout=None):
    method notify_ready (line 534) | def notify_ready(self, apply_result=None):
  class OrderedResultCollector (line 555) | class OrderedResultCollector(AbstractResultCollector):
    method __init__ (line 561) | def __init__(self, to_notify=None, as_iterator=True):
    method register_result (line 576) | def register_result(self, apply_result):
    method _get_result (line 586) | def _get_result(self, idx, timeout=None):
    method notify_ready (line 599) | def notify_ready(self, apply_result):

FILE: third-party/tbb/python/tbb/test.py
  function test (line 53) | def test(arg=None):

FILE: third-party/tbb/src/tbb/address_waiter.cpp
  type tbb (line 24) | namespace tbb {
    type detail (line 25) | namespace detail {
      type r1 (line 26) | namespace r1 {
        type address_context (line 28) | struct address_context {
          method address_context (line 29) | address_context() = default;
          method address_context (line 31) | address_context(void* address, std::uintptr_t context) :
        class address_waiter (line 39) | class address_waiter : public concurrent_monitor_base<address_cont...
        function clear_address_waiter_table (line 58) | void clear_address_waiter_table() {
        function address_waiter (line 64) | static address_waiter& get_address_waiter(void* address) {
        function wait_on_address (line 69) | void wait_on_address(void* address, d1::delegate_base& predicate, ...
        function notify_by_address (line 74) | void notify_by_address(void* address, std::uintptr_t target_contex...
        function notify_by_address_one (line 84) | void notify_by_address_one(void* address) {
        function notify_by_address_all (line 94) | void notify_by_address_all(void* address) {

FILE: third-party/tbb/src/tbb/allocator.cpp
  type tbb (line 70) | namespace tbb {
    type detail (line 71) | namespace detail {
      type r1 (line 72) | namespace r1 {
        function initialize_handler_pointers (line 134) | void initialize_handler_pointers() {
        function initialize_cache_aligned_allocator (line 155) | void initialize_cache_aligned_allocator() {
        function std_cache_aligned_deallocate (line 242) | static void std_cache_aligned_deallocate(void* p) {

FILE: third-party/tbb/src/tbb/arena.cpp
  type tbb (line 32) | namespace tbb {
    type detail (line 33) | namespace detail {
      type r1 (line 34) | namespace r1 {
        class numa_binding_observer (line 37) | class numa_binding_observer : public tbb::task_scheduler_observer {
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function numa_binding_observer (line 58) | numa_binding_observer* construct_binding_observer( d1::task_arena*...
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function destroy_binding_observer (line 67) | void destroy_binding_observer( numa_binding_observer* binding_obse...
        function arena (line 290) | arena& arena::allocate_arena(threading_control* control, unsigned ...
        function thread_control_monitor (line 451) | thread_control_monitor& arena::get_waiting_threads_monitor() {
        function arena (line 463) | arena &arena::create(threading_control *control, unsigned num_slots,
        function assert_arena_priority_valid (line 496) | void assert_arena_priority_valid( tbb::task_arena::priority a_prio...
        function assert_arena_priority_valid (line 505) | void assert_arena_priority_valid( tbb::task_arena::priority ) {}
        function arena_priority_level (line 508) | unsigned arena_priority_level( tbb::task_arena::priority a_priorit...
        function arena_priority (line 513) | tbb::task_arena::priority arena_priority( unsigned priority_level ) {
        type task_arena_impl (line 521) | struct task_arena_impl {
        class nested_arena_context (line 678) | class nested_arena_context : no_copy {
          method nested_arena_context (line 680) | nested_arena_context(thread_data& td, arena& nested_arena, std::...
        class delegated_task (line 761) | class delegated_task : public d1::task {
          method finalize (line 789) | void finalize() {
          method delegated_task (line 797) | delegated_task(d1::delegate_base& d, concurrent_monitor& s, d1::...
        function isolate_within_arena (line 935) | void isolate_within_arena(d1::delegate_base& d, std::intptr_t isol...
      type r1 (line 493) | namespace r1 {
        class numa_binding_observer (line 37) | class numa_binding_observer : public tbb::task_scheduler_observer {
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function numa_binding_observer (line 58) | numa_binding_observer* construct_binding_observer( d1::task_arena*...
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function destroy_binding_observer (line 67) | void destroy_binding_observer( numa_binding_observer* binding_obse...
        function arena (line 290) | arena& arena::allocate_arena(threading_control* control, unsigned ...
        function thread_control_monitor (line 451) | thread_control_monitor& arena::get_waiting_threads_monitor() {
        function arena (line 463) | arena &arena::create(threading_control *control, unsigned num_slots,
        function assert_arena_priority_valid (line 496) | void assert_arena_priority_valid( tbb::task_arena::priority a_prio...
        function assert_arena_priority_valid (line 505) | void assert_arena_priority_valid( tbb::task_arena::priority ) {}
        function arena_priority_level (line 508) | unsigned arena_priority_level( tbb::task_arena::priority a_priorit...
        function arena_priority (line 513) | tbb::task_arena::priority arena_priority( unsigned priority_level ) {
        type task_arena_impl (line 521) | struct task_arena_impl {
        class nested_arena_context (line 678) | class nested_arena_context : no_copy {
          method nested_arena_context (line 680) | nested_arena_context(thread_data& td, arena& nested_arena, std::...
        class delegated_task (line 761) | class delegated_task : public d1::task {
          method finalize (line 789) | void finalize() {
          method delegated_task (line 797) | delegated_task(d1::delegate_base& d, concurrent_monitor& s, d1::...
        function isolate_within_arena (line 935) | void isolate_within_arena(d1::delegate_base& d, std::intptr_t isol...
    type detail (line 492) | namespace detail {
      type r1 (line 34) | namespace r1 {
        class numa_binding_observer (line 37) | class numa_binding_observer : public tbb::task_scheduler_observer {
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function numa_binding_observer (line 58) | numa_binding_observer* construct_binding_observer( d1::task_arena*...
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function destroy_binding_observer (line 67) | void destroy_binding_observer( numa_binding_observer* binding_obse...
        function arena (line 290) | arena& arena::allocate_arena(threading_control* control, unsigned ...
        function thread_control_monitor (line 451) | thread_control_monitor& arena::get_waiting_threads_monitor() {
        function arena (line 463) | arena &arena::create(threading_control *control, unsigned num_slots,
        function assert_arena_priority_valid (line 496) | void assert_arena_priority_valid( tbb::task_arena::priority a_prio...
        function assert_arena_priority_valid (line 505) | void assert_arena_priority_valid( tbb::task_arena::priority ) {}
        function arena_priority_level (line 508) | unsigned arena_priority_level( tbb::task_arena::priority a_priorit...
        function arena_priority (line 513) | tbb::task_arena::priority arena_priority( unsigned priority_level ) {
        type task_arena_impl (line 521) | struct task_arena_impl {
        class nested_arena_context (line 678) | class nested_arena_context : no_copy {
          method nested_arena_context (line 680) | nested_arena_context(thread_data& td, arena& nested_arena, std::...
        class delegated_task (line 761) | class delegated_task : public d1::task {
          method finalize (line 789) | void finalize() {
          method delegated_task (line 797) | delegated_task(d1::delegate_base& d, concurrent_monitor& s, d1::...
        function isolate_within_arena (line 935) | void isolate_within_arena(d1::delegate_base& d, std::intptr_t isol...
      type r1 (line 493) | namespace r1 {
        class numa_binding_observer (line 37) | class numa_binding_observer : public tbb::task_scheduler_observer {
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function numa_binding_observer (line 58) | numa_binding_observer* construct_binding_observer( d1::task_arena*...
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function destroy_binding_observer (line 67) | void destroy_binding_observer( numa_binding_observer* binding_obse...
        function arena (line 290) | arena& arena::allocate_arena(threading_control* control, unsigned ...
        function thread_control_monitor (line 451) | thread_control_monitor& arena::get_waiting_threads_monitor() {
        function arena (line 463) | arena &arena::create(threading_control *control, unsigned num_slots,
        function assert_arena_priority_valid (line 496) | void assert_arena_priority_valid( tbb::task_arena::priority a_prio...
        function assert_arena_priority_valid (line 505) | void assert_arena_priority_valid( tbb::task_arena::priority ) {}
        function arena_priority_level (line 508) | unsigned arena_priority_level( tbb::task_arena::priority a_priorit...
        function arena_priority (line 513) | tbb::task_arena::priority arena_priority( unsigned priority_level ) {
        type task_arena_impl (line 521) | struct task_arena_impl {
        class nested_arena_context (line 678) | class nested_arena_context : no_copy {
          method nested_arena_context (line 680) | nested_arena_context(thread_data& td, arena& nested_arena, std::...
        class delegated_task (line 761) | class delegated_task : public d1::task {
          method finalize (line 789) | void finalize() {
          method delegated_task (line 797) | delegated_task(d1::delegate_base& d, concurrent_monitor& s, d1::...
        function isolate_within_arena (line 935) | void isolate_within_arena(d1::delegate_base& d, std::intptr_t isol...
  type tbb (line 491) | namespace tbb {
    type detail (line 33) | namespace detail {
      type r1 (line 34) | namespace r1 {
        class numa_binding_observer (line 37) | class numa_binding_observer : public tbb::task_scheduler_observer {
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function numa_binding_observer (line 58) | numa_binding_observer* construct_binding_observer( d1::task_arena*...
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function destroy_binding_observer (line 67) | void destroy_binding_observer( numa_binding_observer* binding_obse...
        function arena (line 290) | arena& arena::allocate_arena(threading_control* control, unsigned ...
        function thread_control_monitor (line 451) | thread_control_monitor& arena::get_waiting_threads_monitor() {
        function arena (line 463) | arena &arena::create(threading_control *control, unsigned num_slots,
        function assert_arena_priority_valid (line 496) | void assert_arena_priority_valid( tbb::task_arena::priority a_prio...
        function assert_arena_priority_valid (line 505) | void assert_arena_priority_valid( tbb::task_arena::priority ) {}
        function arena_priority_level (line 508) | unsigned arena_priority_level( tbb::task_arena::priority a_priorit...
        function arena_priority (line 513) | tbb::task_arena::priority arena_priority( unsigned priority_level ) {
        type task_arena_impl (line 521) | struct task_arena_impl {
        class nested_arena_context (line 678) | class nested_arena_context : no_copy {
          method nested_arena_context (line 680) | nested_arena_context(thread_data& td, arena& nested_arena, std::...
        class delegated_task (line 761) | class delegated_task : public d1::task {
          method finalize (line 789) | void finalize() {
          method delegated_task (line 797) | delegated_task(d1::delegate_base& d, concurrent_monitor& s, d1::...
        function isolate_within_arena (line 935) | void isolate_within_arena(d1::delegate_base& d, std::intptr_t isol...
      type r1 (line 493) | namespace r1 {
        class numa_binding_observer (line 37) | class numa_binding_observer : public tbb::task_scheduler_observer {
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function numa_binding_observer (line 58) | numa_binding_observer* construct_binding_observer( d1::task_arena*...
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function destroy_binding_observer (line 67) | void destroy_binding_observer( numa_binding_observer* binding_obse...
        function arena (line 290) | arena& arena::allocate_arena(threading_control* control, unsigned ...
        function thread_control_monitor (line 451) | thread_control_monitor& arena::get_waiting_threads_monitor() {
        function arena (line 463) | arena &arena::create(threading_control *control, unsigned num_slots,
        function assert_arena_priority_valid (line 496) | void assert_arena_priority_valid( tbb::task_arena::priority a_prio...
        function assert_arena_priority_valid (line 505) | void assert_arena_priority_valid( tbb::task_arena::priority ) {}
        function arena_priority_level (line 508) | unsigned arena_priority_level( tbb::task_arena::priority a_priorit...
        function arena_priority (line 513) | tbb::task_arena::priority arena_priority( unsigned priority_level ) {
        type task_arena_impl (line 521) | struct task_arena_impl {
        class nested_arena_context (line 678) | class nested_arena_context : no_copy {
          method nested_arena_context (line 680) | nested_arena_context(thread_data& td, arena& nested_arena, std::...
        class delegated_task (line 761) | class delegated_task : public d1::task {
          method finalize (line 789) | void finalize() {
          method delegated_task (line 797) | delegated_task(d1::delegate_base& d, concurrent_monitor& s, d1::...
        function isolate_within_arena (line 935) | void isolate_within_arena(d1::delegate_base& d, std::intptr_t isol...
    type detail (line 492) | namespace detail {
      type r1 (line 34) | namespace r1 {
        class numa_binding_observer (line 37) | class numa_binding_observer : public tbb::task_scheduler_observer {
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function numa_binding_observer (line 58) | numa_binding_observer* construct_binding_observer( d1::task_arena*...
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function destroy_binding_observer (line 67) | void destroy_binding_observer( numa_binding_observer* binding_obse...
        function arena (line 290) | arena& arena::allocate_arena(threading_control* control, unsigned ...
        function thread_control_monitor (line 451) | thread_control_monitor& arena::get_waiting_threads_monitor() {
        function arena (line 463) | arena &arena::create(threading_control *control, unsigned num_slots,
        function assert_arena_priority_valid (line 496) | void assert_arena_priority_valid( tbb::task_arena::priority a_prio...
        function assert_arena_priority_valid (line 505) | void assert_arena_priority_valid( tbb::task_arena::priority ) {}
        function arena_priority_level (line 508) | unsigned arena_priority_level( tbb::task_arena::priority a_priorit...
        function arena_priority (line 513) | tbb::task_arena::priority arena_priority( unsigned priority_level ) {
        type task_arena_impl (line 521) | struct task_arena_impl {
        class nested_arena_context (line 678) | class nested_arena_context : no_copy {
          method nested_arena_context (line 680) | nested_arena_context(thread_data& td, arena& nested_arena, std::...
        class delegated_task (line 761) | class delegated_task : public d1::task {
          method finalize (line 789) | void finalize() {
          method delegated_task (line 797) | delegated_task(d1::delegate_base& d, concurrent_monitor& s, d1::...
        function isolate_within_arena (line 935) | void isolate_within_arena(d1::delegate_base& d, std::intptr_t isol...
      type r1 (line 493) | namespace r1 {
        class numa_binding_observer (line 37) | class numa_binding_observer : public tbb::task_scheduler_observer {
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function numa_binding_observer (line 58) | numa_binding_observer* construct_binding_observer( d1::task_arena*...
          method numa_binding_observer (line 40) | numa_binding_observer( d1::task_arena* ta, int num_slots, int nu...
          method on_scheduler_entry (line 45) | void on_scheduler_entry( bool ) override {
          method on_scheduler_exit (line 49) | void on_scheduler_exit( bool ) override {
        function destroy_binding_observer (line 67) | void destroy_binding_observer( numa_binding_observer* binding_obse...
        function arena (line 290) | arena& arena::allocate_arena(threading_control* control, unsigned ...
        function thread_control_monitor (line 451) | thread_control_monitor& arena::get_waiting_threads_monitor() {
        function arena (line 463) | arena &arena::create(threading_control *control, unsigned num_slots,
        function assert_arena_priority_valid (line 496) | void assert_arena_priority_valid( tbb::task_arena::priority a_prio...
        function assert_arena_priority_valid (line 505) | void assert_arena_priority_valid( tbb::task_arena::priority ) {}
        function arena_priority_level (line 508) | unsigned arena_priority_level( tbb::task_arena::priority a_priorit...
        function arena_priority (line 513) | tbb::task_arena::priority arena_priority( unsigned priority_level ) {
        type task_arena_impl (line 521) | struct task_arena_impl {
        class nested_arena_context (line 678) | class nested_arena_context : no_copy {
          method nested_arena_context (line 680) | nested_arena_context(thread_data& td, arena& nested_arena, std::...
        class delegated_task (line 761) | class delegated_task : public d1::task {
          method finalize (line 789) | void finalize() {
          method delegated_task (line 797) | delegated_task(d1::delegate_base& d, concurrent_monitor& s, d1::...
        function isolate_within_arena (line 935) | void isolate_within_arena(d1::delegate_base& d, std::intptr_t isol...

FILE: third-party/tbb/src/tbb/arena.h
  function class (line 53) | class arena_co_cache {
  type stack_anchor_type (line 134) | struct stack_anchor_type {
  function class (line 139) | class atomic_flag {
  function reset_if_needed (line 204) | void reset_if_needed() {
  function register_parallel_phase (line 214) | void register_parallel_phase() {
  function unregister_parallel_phase (line 227) | void unregister_parallel_phase(bool enable_fast_leave) {
  function is_retention_allowed (line 242) | bool is_retention_allowed() {
  type arena_base (line 254) | struct arena_base
  function numa_binding_observer (line 303) | numa_binding_observer* my_numa_binding_observer{nullptr};
  type new_work_type (line 350) | enum new_work_type {
  function num_arena_slots (line 379) | static int unsigned num_arena_slots ( unsigned num_slots, unsigned num_r...
  function allocation_size (line 383) | static int allocation_size( unsigned num_slots ) {
  function is_empty (line 450) | bool is_empty() { return my_pool_state.test() == /* EMPTY */ false; }
  function priority_level (line 463) | unsigned priority_level() { return my_priority_level; }
  function has_request (line 465) | bool has_request() { return my_total_num_workers_requested; }
  function is_top_priority (line 473) | bool is_top_priority() const;
  function d1 (line 530) | inline d1::task* arena::steal_task(unsigned arena_index, FastRandom& frn...
  function d1 (line 586) | inline d1::task* arena::get_critical_task(unsigned& hint, isolation_type...

FILE: third-party/tbb/src/tbb/arena_slot.cpp
  type tbb (line 21) | namespace tbb {
    type detail (line 22) | namespace detail {
      type r1 (line 23) | namespace r1 {

FILE: third-party/tbb/src/tbb/arena_slot.h
  function namespace (line 33) | namespace tbb {

FILE: third-party/tbb/src/tbb/assert_impl.h
  function namespace (line 34) | namespace rml { namespace internal {

FILE: third-party/tbb/src/tbb/cancellation_disseminator.h
  function namespace (line 26) | namespace tbb {

FILE: third-party/tbb/src/tbb/co_context.h
  type coroutine_type (line 72) | struct coroutine_type {
  function my_is_active (line 83) | bool my_is_active{ true };
  type LPVOID (line 86) | typedef LPVOID coroutine_type;
  type coroutine_type (line 88) | struct coroutine_type {
  function class (line 102) | class co_context {
  function check (line 159) | inline void check(int error_code, const char* routine) {
  function create_coroutine (line 206) | inline void create_coroutine(coroutine_type& c, std::size_t stack_size, ...

FILE: third-party/tbb/src/tbb/concurrent_bounded_queue.cpp
  type tbb (line 22) | namespace tbb {
    type detail (line 23) | namespace detail {
      type r1 (line 24) | namespace r1 {
        type predicate_leq (line 68) | struct predicate_leq {
          method predicate_leq (line 70) | predicate_leq( std::size_t ticket ) : my_ticket(ticket) {}

FILE: third-party/tbb/src/tbb/concurrent_monitor.h
  function namespace (line 30) | namespace r1 {
  function virtual (line 114) | virtual void init() {
  function virtual (line 121) | virtual void reset() {
  function Context (line 132) | Context my_context{}
  function my_initialized (line 139) | bool my_initialized{false};

FILE: third-party/tbb/src/tbb/concurrent_monitor_mutex.h
  function namespace (line 27) | namespace detail {

FILE: third-party/tbb/src/tbb/dynamic_link.cpp
  type tbb (line 104) | namespace tbb {
    type detail (line 105) | namespace detail {
      type r1 (line 106) | namespace r1 {
        function dynamic_link_warning (line 113) | static void dynamic_link_warning( dynamic_link_error_t code, ... ) {
        function resolve_symbols (line 118) | static bool resolve_symbols( dynamic_link_handle module, const dyn...
        function dynamic_link (line 149) | bool dynamic_link( const char*  library, const dynamic_link_descri...
        function dynamic_unlink (line 161) | void dynamic_unlink( dynamic_link_handle ) {}
        function dynamic_unlink_all (line 162) | void dynamic_unlink_all() {}
        type handles_t (line 191) | struct handles_t {
          method add (line 195) | void add(const dynamic_link_handle &handle) {
          method free (line 201) | void free() {
        type ap_data_t (line 210) | struct ap_data_t {
        function init_ap_data (line 215) | static void init_ap_data() {
        function init_dl_data (line 298) | static void init_dl_data() {
        function abs_path (line 314) | static std::size_t abs_path( char const * name, char * path, std::...
        function init_dynamic_link_data (line 331) | void init_dynamic_link_data() {
        type static_init_dl_data_t (line 341) | struct static_init_dl_data_t {
          method static_init_dl_data_t (line 342) | static_init_dl_data_t() {
        function weak_symbol_link (line 349) | static bool weak_symbol_link( const dynamic_link_descriptor descri...
        function weak_symbol_link (line 361) | static bool weak_symbol_link( const dynamic_link_descriptor[], std...
        function dynamic_unlink (line 366) | void dynamic_unlink( dynamic_link_handle handle ) {
        function dynamic_unlink_all (line 375) | void dynamic_unlink_all() {
        function dynamic_link_handle (line 381) | static dynamic_link_handle global_symbols_link( const char* librar...
        function save_library_handle (line 403) | static void save_library_handle( dynamic_link_handle src, dynamic_...
        function loading_flags (line 414) | int loading_flags(bool local_binding) {
        function dynamic_link_handle (line 430) | dynamic_link_handle dynamic_load( const char* library, const dynam...
        function dynamic_link (line 464) | bool dynamic_link( const char* library, const dynamic_link_descrip...
        function dynamic_link (line 493) | bool dynamic_link( const char*, const dynamic_link_descriptor*, st...
        function dynamic_unlink (line 498) | void dynamic_unlink( dynamic_link_handle ) {}
        function dynamic_unlink_all (line 499) | void dynamic_unlink_all() {}

FILE: third-party/tbb/src/tbb/dynamic_link.h
  function namespace (line 36) | namespace tbb {

FILE: third-party/tbb/src/tbb/environment.h
  function namespace (line 25) | namespace tbb {

FILE: third-party/tbb/src/tbb/exception.cpp
  type tbb (line 35) | namespace tbb {
    type detail (line 36) | namespace detail {
      type r1 (line 37) | namespace r1 {
        function do_throw_noexcept (line 45) | void do_throw_noexcept(F throw_func) noexcept {
        function do_throw_noexcept (line 49) | void do_throw_noexcept(void (*throw_func)()) noexcept {
        function do_throw (line 62) | void do_throw(F throw_func) {
        function throw_exception (line 79) | void throw_exception ( exception_id eid ) {
        function handle_perror (line 104) | void handle_perror( int error_code, const char* what ) {
        function fix_broken_rethrow (line 130) | void fix_broken_rethrow() {
        function gcc_rethrow_exception_broken (line 139) | bool gcc_rethrow_exception_broken() {
        function fix_broken_rethrow (line 159) | void fix_broken_rethrow() {}
        function gcc_rethrow_exception_broken (line 160) | bool gcc_rethrow_exception_broken() { return false; }

FILE: third-party/tbb/src/tbb/global_control.cpp
  type tbb (line 33) | namespace tbb {
    type detail (line 34) | namespace detail {
      type r1 (line 35) | namespace r1 {
        type control_storage_comparator (line 38) | struct control_storage_comparator {
        class control_storage (line 42) | class control_storage {
          method apply_active (line 55) | virtual void apply_active(std::size_t new_active) {
          method is_first_arg_preferred (line 58) | virtual bool is_first_arg_preferred(std::size_t a, std::size_t b...
          method active_value (line 61) | virtual std::size_t active_value() {
          method active_value_unsafe (line 66) | std::size_t active_value_unsafe() {
        class allowed_parallelism_control (line 71) | class alignas(max_nfs_size) allowed_parallelism_control : public c...
          method default_value (line 72) | std::size_t default_value() const override {
          method is_first_arg_preferred (line 75) | bool is_first_arg_preferred(std::size_t a, std::size_t b) const ...
          method apply_active (line 78) | void apply_active(std::size_t new_active) override {
          method active_value (line 84) | std::size_t active_value() override {
        class stack_size_control (line 98) | class alignas(max_nfs_size) stack_size_control : public control_st...
          method default_value (line 99) | std::size_t default_value() const override {
          method apply_active (line 113) | void apply_active(std::size_t new_active) override {
        class terminate_on_exception_control (line 121) | class alignas(max_nfs_size) terminate_on_exception_control : publi...
          method default_value (line 122) | std::size_t default_value() const override {
        class lifetime_control (line 127) | class alignas(max_nfs_size) lifetime_control : public control_stor...
          method is_first_arg_preferred (line 128) | bool is_first_arg_preferred(std::size_t, std::size_t) const over...
          method default_value (line 131) | std::size_t default_value() const override {
          method apply_active (line 134) | void apply_active(std::size_t new_active) override {
        function global_control_acquire (line 147) | void global_control_acquire() {
        function global_control_release (line 154) | void global_control_release() {
        function global_control_lock (line 162) | void global_control_lock() {
        function global_control_unlock (line 168) | void global_control_unlock() {
        function global_control_active_value_unsafe (line 175) | std::size_t global_control_active_value_unsafe(d1::global_control:...
        function terminate_on_exception (line 186) | bool terminate_on_exception() {
        type global_control_impl (line 190) | struct global_control_impl {
          method erase_if_present (line 192) | static bool erase_if_present(control_storage* const c, d1::globa...
          method create (line 203) | static void create(d1::global_control& gc) {
          method destroy (line 216) | static void destroy(d1::global_control& gc) {
          method remove_and_check_if_empty (line 239) | static bool remove_and_check_if_empty(d1::global_control& gc) {
          method is_present (line 249) | static bool is_present(d1::global_control& gc) {
        function remove_and_check_if_empty (line 270) | bool remove_and_check_if_empty(d1::global_control& gc) {
        function is_present (line 274) | bool is_present(d1::global_control& gc) {

FILE: third-party/tbb/src/tbb/governor.cpp
  type tbb (line 44) | namespace tbb {
    type detail (line 45) | namespace detail {
      type r1 (line 46) | namespace r1 {
        type rml (line 60) | namespace rml {
        type system_topology (line 64) | namespace system_topology {
          function processor_groups_num (line 468) | int processor_groups_num() {
          function initialization_impl (line 480) | void initialization_impl() {
          function initialize (line 505) | void initialize() {
          function destroy (line 509) | void destroy() {
        function get_stack_attributes (line 154) | static void get_stack_attributes(std::uintptr_t& stack_base, std::...
        function register_external_thread_destructor (line 195) | static void register_external_thread_destructor() {
        function release_impl (line 290) | void release_impl(d1::task_scheduler_handle& handle) {
        function finalize_impl (line 298) | bool finalize_impl(d1::task_scheduler_handle& handle) {
        function dummy_destroy_system_topology (line 369) | static void dummy_destroy_system_topology ( ) { }
        function binding_handler (line 370) | static binding_handler* dummy_allocate_binding_handler ( int, int,...
        function dummy_deallocate_binding_handler (line 371) | static void dummy_deallocate_binding_handler ( binding_handler* ) { }
        function dummy_apply_affinity (line 372) | static void dummy_apply_affinity ( binding_handler*, int ) { }
        function dummy_restore_affinity (line 373) | static void dummy_restore_affinity ( binding_handler*, int ) { }
        function dummy_get_default_concurrency (line 374) | static int dummy_get_default_concurrency( int, int, int ) { return...
        type system_topology (line 438) | namespace system_topology {
          function processor_groups_num (line 468) | int processor_groups_num() {
          function initialization_impl (line 480) | void initialization_impl() {
          function initialize (line 505) | void initialize() {
          function destroy (line 509) | void destroy() {
        function binding_handler (line 514) | binding_handler* construct_binding_handler(int slot_num, int numa_...
        function destroy_binding_handler (line 519) | void destroy_binding_handler(binding_handler* handler_ptr) {
        function apply_affinity_mask (line 524) | void apply_affinity_mask(binding_handler* handler_ptr, int slot_in...
        function restore_affinity_mask (line 530) | void restore_affinity_mask(binding_handler* handler_ptr, int slot_...
        function numa_node_count (line 536) | unsigned __TBB_EXPORTED_FUNC numa_node_count() {
        function core_type_count (line 559) | unsigned __TBB_EXPORTED_FUNC core_type_count(intptr_t /*reserved*/) {
        function constraints_assertion (line 569) | void constraints_assertion(d1::constraints c) {

FILE: third-party/tbb/src/tbb/governor.h
  function namespace (line 25) | namespace tbb {

FILE: third-party/tbb/src/tbb/intrusive_list.h
  function namespace (line 22) | namespace tbb {
  function T (line 198) | static T& item ( intrusive_list_node* node ) {
  function T (line 206) | static const T& item( const intrusive_list_node* node ) {
  function T (line 224) | static T& item ( intrusive_list_node* node ) { return *static_cast<T*>(n...
  function T (line 226) | static const T& item( const intrusive_list_node* node ) { return *static...

FILE: third-party/tbb/src/tbb/itt_notify.cpp
  type tbb (line 45) | namespace tbb {
    type detail (line 46) | namespace detail {
      type r1 (line 47) | namespace r1 {
        function __TBB_load_ittnotify (line 50) | int __TBB_load_ittnotify() {

FILE: third-party/tbb/src/tbb/itt_notify.h
  function namespace (line 49) | namespace tbb {

FILE: third-party/tbb/src/tbb/mailbox.h
  function namespace (line 27) | namespace tbb {

FILE: third-party/tbb/src/tbb/main.cpp
  type tbb (line 28) | namespace tbb {
    type detail (line 29) | namespace detail {
      type r1 (line 30) | namespace r1 {
        function DoOneTimeInitialization (line 104) | void DoOneTimeInitialization() {
        function DllMain (line 132) | bool WINAPI DllMain( HANDLE /*hinstDLL*/, DWORD reason, LPVOID lpv...

FILE: third-party/tbb/src/tbb/main.h
  function namespace (line 24) | namespace tbb {

FILE: third-party/tbb/src/tbb/market.cpp
  type tbb (line 22) | namespace tbb {
    type detail (line 23) | namespace detail {
      type r1 (line 24) | namespace r1 {
        class tbb_permit_manager_client (line 27) | class tbb_permit_manager_client : public pm_client {
          method tbb_permit_manager_client (line 29) | tbb_permit_manager_client(arena& a) : pm_client(a) {}
          method register_thread (line 31) | void register_thread() override {}
          method unregister_thread (line 33) | void unregister_thread() override {}
          method set_allotment (line 35) | void set_allotment(unsigned allotment) {
        function pm_client (line 48) | pm_client* market::create_client(arena& a) {

FILE: third-party/tbb/src/tbb/market.h
  function namespace (line 30) | namespace tbb {

FILE: third-party/tbb/src/tbb/market_concurrent_monitor.h
  function namespace (line 25) | namespace tbb {

FILE: third-party/tbb/src/tbb/misc.cpp
  type tbb (line 44) | namespace tbb {
    type detail (line 45) | namespace detail {
      type r1 (line 46) | namespace r1 {
        function DefaultSystemPageSize (line 61) | size_t DefaultSystemPageSize() {
        function PrintVersion (line 76) | void PrintVersion() {
        function PrintExtraVersionInfo (line 81) | void PrintExtraVersionInfo( const char* category, const char* form...
        function check_cpuid (line 100) | void check_cpuid(int leaf, int sub_leaf, int registers[4]) {
        function detect_cpu_features (line 131) | void detect_cpu_features(cpu_features_type& cpu_features) {

FILE: third-party/tbb/src/tbb/misc.h
  function namespace (line 43) | namespace tbb {

FILE: third-party/tbb/src/tbb/misc_ex.cpp
  type tbb (line 52) | namespace tbb {
    type detail (line 53) | namespace detail {
      type r1 (line 54) | namespace r1 {
        function set_thread_affinity_mask (line 67) | static void set_thread_affinity_mask( std::size_t maskSize, const ...
        function get_thread_affinity_mask (line 80) | static void get_thread_affinity_mask( std::size_t maskSize, basic_...
        function destroy_process_mask (line 92) | void destroy_process_mask() {
        function initialize_hardware_concurrency_info (line 133) | static void initialize_hardware_concurrency_info () {
        function AvailableHwConcurrency (line 197) | int AvailableHwConcurrency() {
        function AvailableHwConcurrency (line 207) | int AvailableHwConcurrency() {
        function AvailableHwConcurrency (line 224) | int AvailableHwConcurrency() {
        type ProcessorGroupInfo (line 239) | struct ProcessorGroupInfo {
        type TBB_GROUP_AFFINITY (line 263) | struct TBB_GROUP_AFFINITY {
        function initialize_hardware_concurrency_info (line 269) | static DWORD (WINAPI *TBB_GetActiveProcessorCount)( WORD groupInde...
        function NumberOfProcessorGroups (line 357) | int NumberOfProcessorGroups() {
        function FindProcessorGroupIndex (line 362) | int FindProcessorGroupIndex ( int procIdx ) {
        function MoveThreadIntoProcessorGroup (line 387) | void MoveThreadIntoProcessorGroup( void* hThread, int groupIndex ) {
        function AvailableHwConcurrency (line 395) | int AvailableHwConcurrency() {

FILE: third-party/tbb/src/tbb/observer_proxy.cpp
  type tbb (line 27) | namespace tbb {
    type detail (line 28) | namespace detail {
      type r1 (line 29) | namespace r1 {

FILE: third-party/tbb/src/tbb/observer_proxy.h
  function namespace (line 28) | namespace r1 {

FILE: third-party/tbb/src/tbb/parallel_pipeline.cpp
  type tbb (line 26) | namespace tbb {
    type detail (line 27) | namespace detail {
      type r1 (line 28) | namespace r1 {
        class pipeline (line 36) | class pipeline {
          method pipeline (line 41) | pipeline(d1::task_group_context& cxt, std::size_t max_token) :
          method fill_pipeline (line 57) | void fill_pipeline(const d1::filter_node& root) {
        type task_info (line 91) | struct task_info {
          method reset (line 100) | void reset() {
        class input_buffer (line 110) | class input_buffer {
          method input_buffer (line 152) | input_buffer(const input_buffer&) = delete;
          method input_buffer (line 153) | input_buffer& operator=(const input_buffer&) = delete;
          method input_buffer (line 156) | input_buffer( bool ordered) :
          method Token (line 179) | Token get_ordered_token(){
          method try_put_token (line 187) | bool try_put_token( task_info& info ) {
          method try_to_spawn_task_for_next_token (line 216) | void try_to_spawn_task_for_next_token(StageTask& spawner, d1::ex...
          method create_my_tls (line 231) | void create_my_tls() {
          method destroy_my_tls (line 237) | void destroy_my_tls() {
          method my_tls_end_of_input (line 242) | bool my_tls_end_of_input() {
          method set_my_tls_end_of_input (line 245) | void set_my_tls_end_of_input() {
        class stage_task (line 268) | class stage_task : public d1::task, public task_info {
          method try_spawn_stage_task (line 281) | void try_spawn_stage_task(d1::execution_data& ed) {
          method stage_task (line 293) | stage_task(pipeline& pipeline, d1::small_object_allocator& alloc...
          method stage_task (line 303) | stage_task(pipeline& pipeline, d1::base_filter* filter, const ta...
          method reset (line 313) | void reset() {
          method finalize (line 318) | void finalize(d1::execution_data& ed) {
          method task (line 322) | task* execute(d1::execution_data& ed) override {
          method task (line 329) | task* cancel(d1::execution_data& ed) override {
          method spawn_stage_task (line 342) | void spawn_stage_task(const task_info& info, d1::execution_data&...

FILE: third-party/tbb/src/tbb/permit_manager.h
  function namespace (line 24) | namespace tbb {

FILE: third-party/tbb/src/tbb/pm_client.h
  function namespace (line 22) | namespace tbb {

FILE: third-party/tbb/src/tbb/private_server.cpp
  type tbb (line 30) | namespace tbb {
    type detail (line 31) | namespace detail {
      type r1 (line 32) | namespace r1 {
        type rml (line 33) | namespace rml {
          class private_server (line 38) | class private_server
            method propagate_chain_reaction (line 156) | void propagate_chain_reaction() {
            method remove_server_ref (line 170) | void remove_server_ref() {
            method version_type (line 182) | version_type version() const override {
            method request_close_connection (line 186) | void request_close_connection( bool /*exiting*/ ) override {
            method yield (line 192) | void yield() override { d0::yield(); }
            method independent_thread_number_changed (line 194) | void independent_thread_number_changed( int ) override {__TBB_...
            method default_concurrency (line 196) | unsigned default_concurrency() const override { return governo...
            method register_external_thread (line 201) | void register_external_thread ( ::rml::server::execution_resou...
            method unregister_external_thread (line 202) | void unregister_external_thread ( ::rml::server::execution_res...
          class private_worker (line 40) | class private_worker: no_copy {
            type state_t (line 49) | enum state_t {
            method private_worker (line 97) | private_worker( private_server& server, tbb_client& client, co...
          class padded_private_worker (line 110) | class padded_private_worker: public private_worker {
            method padded_private_worker (line 113) | padded_private_worker( private_server& server, tbb_client& cli...
          class private_server (line 120) | class private_server: public tbb_server, no_copy {
            method propagate_chain_reaction (line 156) | void propagate_chain_reaction() {
            method remove_server_ref (line 170) | void remove_server_ref() {
            method version_type (line 182) | version_type version() const override {
            method request_close_connection (line 186) | void request_close_connection( bool /*exiting*/ ) override {
            method yield (line 192) | void yield() override { d0::yield(); }
            method independent_thread_number_changed (line 194) | void independent_thread_number_changed( int ) override {__TBB_...
            method default_concurrency (line 196) | unsigned default_concurrency() const override { return governo...
            method register_external_thread (line 201) | void register_external_thread ( ::rml::server::execution_resou...
            method unregister_external_thread (line 202) | void unregister_external_thread ( ::rml::server::execution_res...
          function __RML_DECL_THREAD_ROUTINE (line 216) | __attribute__((force_align_arg_pointer))
          function tbb_server (line 428) | tbb_server* make_private_server( tbb_client& client ) {

FILE: third-party/tbb/src/tbb/profiling.cpp
  type tbb (line 27) | namespace tbb {
    type detail (line 28) | namespace detail {
      type r1 (line 29) | namespace r1 {
        type resource_string (line 37) | struct resource_string {
        function __itt_string_handle (line 52) | static __itt_string_handle* ITT_get_string_handle(std::uintptr_t i...
        function ITT_init_domains (line 57) | static void ITT_init_domains() {
        function ITT_init_strings (line 66) | static void ITT_init_strings() {
        function ITT_init (line 76) | static void ITT_init() {
        function ITT_DoUnsafeOneTimeInitialization (line 83) | void ITT_DoUnsafeOneTimeInitialization () {
        function ITT_DoOneTimeInitialization (line 96) | void ITT_DoOneTimeInitialization() {
        function create_itt_sync (line 104) | void create_itt_sync(void* ptr, const tchar* objtype, const tchar*...
        function call_itt_notify (line 108) | void call_itt_notify(int t, void *ptr) {
        function itt_set_sync_name (line 118) | void itt_set_sync_name(void* obj, const tchar* name) {
        function __itt_domain (line 124) | static inline __itt_domain* get_itt_domain(d1::itt_domain_enum idx) {
        function itt_id_make (line 131) | static inline void itt_id_make(__itt_id* id, void* addr, unsigned ...
        function itt_id_create (line 135) | static inline void itt_id_create(const __itt_domain* domain, __itt...
        function itt_make_task_group (line 139) | void itt_make_task_group(d1::itt_domain_enum domain, void* group, ...
        function create_itt_sync (line 238) | void create_itt_sync(void* /*ptr*/, const tchar* /*objtype*/, cons...
        function call_itt_notify (line 239) | void call_itt_notify(int /*t*/, void* /*ptr*/) {}
        function itt_set_sync_name (line 240) | void itt_set_sync_name(void* /*obj*/, const tchar* /*name*/) {}
        function itt_make_task_group (line 241) | void itt_make_task_group(d1::itt_domain_enum /*domain*/, void* /*g...
        function itt_metadata_str_add (line 243) | void itt_metadata_str_add(d1::itt_domain_enum /*domain*/, void* /*...
        function itt_metadata_ptr_add (line 245) | void itt_metadata_ptr_add(d1::itt_domain_enum /*domain*/, void * /...
        function itt_relation_add (line 247) | void itt_relation_add(d1::itt_domain_enum /*domain*/, void* /*addr...
        function itt_task_begin (line 249) | void itt_task_begin(d1::itt_domain_enum /*domain*/, void* /*task*/...
        function itt_task_end (line 251) | void itt_task_end(d1::itt_domain_enum /*domain*/ ) { }
        function itt_region_begin (line 252) | void itt_region_begin(d1::itt_domain_enum /*domain*/, void* /*regi...
        function itt_region_end (line 254) | void itt_region_end(d1::itt_domain_enum /*domain*/, void* /*region...

FILE: third-party/tbb/src/tbb/queuing_rw_mutex.cpp
  type tbb (line 26) | namespace tbb {
    type detail (line 27) | namespace detail {
      type r1 (line 28) | namespace r1 {
        class tricky_atomic_pointer (line 38) | class tricky_atomic_pointer {
          method T (line 42) | static T* fetch_add( std::atomic<word>& location, word addend, s...
          method T (line 46) | static T* exchange( std::atomic<word>& location, T* value, std::...
          method T (line 50) | static T* compare_exchange_strong( std::atomic<word>& obj, const...
          method store (line 56) | static void store( std::atomic<word>& location, const T* value, ...
          method T (line 60) | static T* load( std::atomic<word>& location, std::memory_order m...
          method spin_wait_while_eq (line 64) | static void spin_wait_while_eq(const std::atomic<word>& location...
          method tricky_atomic_pointer (line 69) | tricky_atomic_pointer( T*& original ) : ref(original) {}
          method tricky_atomic_pointer (line 70) | tricky_atomic_pointer(const tricky_atomic_pointer&) = delete;
          method tricky_atomic_pointer (line 71) | tricky_atomic_pointer& operator=(const tricky_atomic_pointer&) =...
          method T (line 72) | T* operator&( const word operand2 ) const {
          method T (line 75) | T* operator|( const word operand2 ) const {
        type state_t_flags (line 88) | enum state_t_flags : unsigned char {
        type queuing_rw_mutex_impl (line 105) | struct queuing_rw_mutex_impl {
          method try_acquire_internal_lock (line 108) | static bool try_acquire_internal_lock(d1::queuing_rw_mutex::scop...
          method acquire_internal_lock (line 115) | static void acquire_internal_lock(d1::queuing_rw_mutex::scoped_l...
          method release_internal_lock (line 125) | static void release_internal_lock(d1::queuing_rw_mutex::scoped_l...
          method wait_for_release_of_internal_lock (line 131) | static void wait_for_release_of_internal_lock(d1::queuing_rw_mut...
          method unblock_or_wait_on_internal_lock (line 137) | static void unblock_or_wait_on_internal_lock(d1::queuing_rw_mute...
          method get_flag (line 149) | static uintptr_t get_flag( d1::queuing_rw_mutex::scoped_lock* pt...
          method acquire (line 158) | static void acquire(d1::queuing_rw_mutex& m, d1::queuing_rw_mute...
          method try_acquire (line 254) | static bool try_acquire(d1::queuing_rw_mutex& m, d1::queuing_rw_...
          method release (line 281) | static void release(d1::queuing_rw_mutex::scoped_lock& s) {
          method downgrade_to_reader (line 414) | static bool downgrade_to_reader(d1::queuing_rw_mutex::scoped_loc...
          method upgrade_to_writer (line 456) | static bool upgrade_to_writer(d1::queuing_rw_mutex::scoped_lock&...
          method is_writer (line 577) | static bool is_writer(const d1::queuing_rw_mutex::scoped_lock& m) {
          method construct (line 581) | static void construct(d1::queuing_rw_mutex& m) {
        function TBB_EXPORT (line 611) | TBB_EXPORT void __TBB_EXPORTED_FUNC construct(d1::queuing_rw_mutex...

FILE: third-party/tbb/src/tbb/rml_base.h
  function class (line 38) | class versioned_object {
  function class (line 55) | class job {
  function class (line 61) | class client: public versioned_object {

FILE: third-party/tbb/src/tbb/rml_tbb.cpp
  type tbb (line 22) | namespace tbb {
    type detail (line 23) | namespace detail {
      type r1 (line 24) | namespace r1 {
        type rml (line 25) | namespace rml {

FILE: third-party/tbb/src/tbb/rml_tbb.h
  function namespace (line 25) | namespace tbb {

FILE: third-party/tbb/src/tbb/rml_thread_monitor.h
  type HANDLE (line 95) | typedef HANDLE handle_type;
  type pthread_t (line 104) | typedef pthread_t handle_type;
  function detach_thread (line 170) | void thread_monitor::detach_thread(handle_type handle) {

FILE: third-party/tbb/src/tbb/rtm_mutex.cpp
  type tbb (line 25) | namespace tbb {
    type detail (line 26) | namespace detail {
      type r1 (line 27) | namespace r1 {
        type rtm_mutex_impl (line 30) | struct rtm_mutex_impl {
          method release (line 37) | static void release(d1::rtm_mutex::scoped_lock& s) {
          method acquire (line 58) | static void acquire(d1::rtm_mutex& m, d1::rtm_mutex::scoped_lock...
          method try_acquire (line 92) | static bool try_acquire(d1::rtm_mutex& m, d1::rtm_mutex::scoped_...

FILE: third-party/tbb/src/tbb/rtm_rw_mutex.cpp
  type tbb (line 25) | namespace tbb {
    type detail (line 26) | namespace detail {
      type r1 (line 27) | namespace r1 {
        type rtm_rw_mutex_impl (line 29) | struct rtm_rw_mutex_impl {
          method release (line 37) | static void release(d1::rtm_rw_mutex::scoped_lock& s) {
          method acquire_writer (line 66) | static void acquire_writer(d1::rtm_rw_mutex& m, d1::rtm_rw_mutex...
          method acquire_reader (line 106) | static void acquire_reader(d1::rtm_rw_mutex& m, d1::rtm_rw_mutex...
          method upgrade (line 151) | static bool upgrade(d1::rtm_rw_mutex::scoped_lock& s) {
          method downgrade (line 180) | static bool downgrade(d1::rtm_rw_mutex::scoped_lock& s) {
          method try_acquire_writer (line 202) | static bool try_acquire_writer(d1::rtm_rw_mutex& m, d1::rtm_rw_m...
          method try_acquire_reader (line 221) | static bool try_acquire_reader(d1::rtm_rw_mutex& m, d1::rtm_rw_m...

FILE: third-party/tbb/src/tbb/scheduler_common.h
  function namespace (line 58) | namespace tbb {
  function finilize_resume (line 398) | void finilize_resume() {
  function try_notify_resume (line 409) | bool try_notify_resume() {
  function recall_owner (line 414) | void recall_owner() {
  type resume_task (line 420) | struct resume_task
  function explicit (line 422) | explicit resume_task(task_dispatcher& target) : m_target(target) {
  type class (line 452) | enum class
  type properties (line 467) | struct properties {
  function critical_task_allowed (line 470) | bool critical_task_allowed{ true };

FILE: third-party/tbb/src/tbb/semaphore.cpp
  type tbb (line 23) | namespace tbb {
    type detail (line 24) | namespace detail {
      type r1 (line 25) | namespace r1 {
        function init_binsem_using_event (line 32) | void WINAPI init_binsem_using_event( SRWLOCK* h_ )
        function acquire_binsem_using_event (line 38) | void WINAPI acquire_binsem_using_event( SRWLOCK* h_ )
        function release_binsem_using_event (line 44) | void WINAPI release_binsem_using_event( SRWLOCK* h_ )
        function init_concmon_module (line 61) | inline void init_concmon_module()

FILE: third-party/tbb/src/tbb/semaphore.h
  function namespace (line 90) | namespace tbb {

FILE: third-party/tbb/src/tbb/small_object_pool.cpp
  type tbb (line 26) | namespace tbb {
    type detail (line 27) | namespace detail {
      type r1 (line 28) | namespace r1 {

FILE: third-party/tbb/src/tbb/small_object_pool_impl.h
  function namespace (line 28) | namespace tbb {

FILE: third-party/tbb/src/tbb/task.cpp
  type tbb (line 32) | namespace tbb {
    type detail (line 33) | namespace detail {
      type r1 (line 34) | namespace r1 {
        function suspend (line 41) | void suspend(suspend_callback_type suspend_callback, void* user_ca...
        function resume (line 47) | void resume(suspend_point_type* sp) {
        function suspend_point_type (line 75) | suspend_point_type* current_suspend_point() {
        function task_dispatcher (line 80) | task_dispatcher& create_coroutine(thread_data& td) {
        function suspend (line 201) | void suspend(suspend_callback_type, void*) {
        function resume (line 205) | void resume(suspend_point_type*) {
        function suspend_point_type (line 209) | suspend_point_type* current_suspend_point() {
        function notify_waiters (line 216) | void notify_waiters(std::uintptr_t wait_ctx_addr) {

FILE: third-party/tbb/src/tbb/task_dispatcher.cpp
  type tbb (line 20) | namespace tbb {
    type detail (line 21) | namespace detail {
      type r1 (line 22) | namespace r1 {
        function spawn_and_notify (line 24) | static inline void spawn_and_notify(d1::task& t, arena_slot* slot,...
        function co_local_wait_for_all (line 188) | void co_local_wait_for_all(unsigned hi, unsigned lo) noexcept

FILE: third-party/tbb/src/tbb/task_dispatcher.h
  function namespace (line 40) | namespace tbb {

FILE: third-party/tbb/src/tbb/task_group_context.cpp
  type tbb (line 28) | namespace tbb {
    type detail (line 29) | namespace detail {
      type r1 (line 30) | namespace r1 {
        function tbb_exception_ptr (line 35) | tbb_exception_ptr* tbb_exception_ptr::allocate() noexcept {

FILE: third-party/tbb/src/tbb/task_stream.h
  function queue_and_mutex (line 46) | alignas(max_nfs_size) queue_and_mutex {
  function set_one_bit (line 56) | inline void set_one_bit( std::atomic<population_t>& dest, int pos ) {
  function clear_one_bit (line 62) | inline void clear_one_bit( std::atomic<population_t>& dest, int pos ) {
  function is_bit_set (line 68) | inline bool is_bit_set( population_t val, int pos ) {
  type random_lane_selector (line 74) | struct random_lane_selector
  function no_assign (line 76) | no_assign
  type lane_selector_base (line 90) | struct lane_selector_base
  function no_assign (line 92) | no_assign
  function lane_selector_base (line 101) | struct subsequent_lane_selector : lane_selector_base {
  function lane_selector_base (line 109) | struct preceding_lane_selector : lane_selector_base {
  function lane_t (line 151) | lane_t* lanes{nullptr};

FILE: third-party/tbb/src/tbb/tcm.h
  type tcm_result_t (line 29) | typedef enum _tcm_result_t {
  type tcm_permit_states_t (line 37) | enum tcm_permit_states_t {
  type tcm_permit_state_t (line 45) | typedef uint8_t tcm_permit_state_t;
  type tcm_permit_flags_t (line 49) | typedef struct _tcm_permit_flags_t {
  type tcm_callback_flags_t (line 57) | typedef struct _tcm_callback_flags_t {
  type hwloc_bitmap_s (line 65) | struct hwloc_bitmap_s
  type hwloc_bitmap_s (line 66) | struct hwloc_bitmap_s
  type hwloc_bitmap_t (line 67) | typedef hwloc_bitmap_t tcm_cpu_mask_t;
  type tcm_client_id_t (line 71) | typedef uint64_t tcm_client_id_t;
  type tcm_permit_t (line 75) | typedef struct _tcm_permit_t {
  type tcm_permit_rep_t (line 85) | struct tcm_permit_rep_t
  type tcm_numa_node_t (line 89) | typedef int32_t tcm_numa_node_t;
  type tcm_core_type_t (line 90) | typedef int32_t tcm_core_type_t;
  type tcm_cpu_constraints_t (line 98) | typedef struct _tcm_cpu_constraints_t {
  type tcm_request_priorities_t (line 109) | enum tcm_request_priorities_t {
  type tcm_request_priority_t (line 115) | typedef int32_t tcm_request_priority_t;
  type tcm_permit_request_t (line 122) | typedef struct _tcm_permit_request_t {
  type tcm_result_t (line 134) | typedef tcm_result_t (*tcm_callback_t)(tcm_permit_handle_t p, void* call...

FILE: third-party/tbb/src/tbb/tcm_adaptor.cpp
  type tbb (line 29) | namespace tbb {
    type detail (line 30) | namespace detail {
      type r1 (line 31) | namespace r1 {
        class tcm_client (line 97) | class tcm_client : public pm_client {
          method tcm_client (line 100) | tcm_client(tcm_adaptor& adaptor, arena& a) : pm_client(a), my_tc...
          method update_concurrency (line 110) | int update_concurrency(uint32_t concurrency) {
          method priority_level (line 114) | unsigned priority_level() {
          method tcm_permit_request_t (line 118) | tcm_permit_request_t& permit_request() {
          method tcm_permit_handle_t (line 122) | tcm_permit_handle_t& permit_handle() {
          method actualize_permit (line 126) | void actualize_permit() {
          method request_permit (line 150) | void request_permit(tcm_client_id_t client_id) {
          method deactivate_permit (line 167) | void deactivate_permit() {
          method init (line 173) | void init(tcm_client_id_t client_id, d1::constraints& constraint...
          method register_thread (line 201) | void register_thread() override {
          method unregister_thread (line 207) | void unregister_thread() override {
        type tcm_adaptor_impl (line 225) | struct tcm_adaptor_impl {
          method tcm_adaptor_impl (line 230) | tcm_adaptor_impl(tcm_client_id_t id) : client_id(id)
        function tcm_result_t (line 238) | tcm_result_t renegotiation_callback(tcm_permit_handle_t, void* cli...
        function pm_client (line 283) | pm_client* tcm_adaptor::create_client(arena& a) {

FILE: third-party/tbb/src/tbb/tcm_adaptor.h
  function namespace (line 25) | namespace tbb {

FILE: third-party/tbb/src/tbb/thread_control_monitor.h
  function namespace (line 25) | namespace tbb {

FILE: third-party/tbb/src/tbb/thread_data.h
  function namespace (line 35) | namespace tbb {

FILE: third-party/tbb/src/tbb/thread_dispatcher.cpp
  type tbb (line 20) | namespace tbb {
    type detail (line 21) | namespace detail {
      type r1 (line 22) | namespace r1 {
        function thread_dispatcher_client (line 37) | thread_dispatcher_client* thread_dispatcher::select_next_client(th...
        function thread_dispatcher_client (line 52) | thread_dispatcher_client* thread_dispatcher::create_client(arena& ...
        function thread_dispatcher_client (line 134) | thread_dispatcher_client* thread_dispatcher::client_in_need(client...
        function thread_dispatcher_client (line 159) | thread_dispatcher_client* thread_dispatcher::client_in_need(thread...

FILE: third-party/tbb/src/tbb/thread_dispatcher.h
  function namespace (line 31) | namespace tbb {

FILE: third-party/tbb/src/tbb/thread_dispatcher_client.h
  function namespace (line 23) | namespace tbb {

FILE: third-party/tbb/src/tbb/thread_request_serializer.cpp
  type tbb (line 20) | namespace tbb {
    type detail (line 21) | namespace detail {
      type r1 (line 22) | namespace r1 {

FILE: third-party/tbb/src/tbb/thread_request_serializer.h
  function namespace (line 27) | namespace r1 {

FILE: third-party/tbb/src/tbb/threading_control.cpp
  type tbb (line 25) | namespace tbb {
    type detail (line 26) | namespace detail {
      type r1 (line 27) | namespace r1 {
        function threading_control_client (line 115) | threading_control_client threading_control_impl::create_client(are...
        function thread_control_monitor (line 171) | thread_control_monitor& threading_control_impl::get_waiting_thread...
        function threading_control (line 204) | threading_control* threading_control::get_threading_control(bool i...
        function threading_control (line 213) | threading_control* threading_control::create_threading_control() {
        function threading_control (line 292) | threading_control* threading_control::register_public_reference() {
        function threading_control_client (line 311) | threading_control_client threading_control::create_client(arena& a) {
        function thread_control_monitor (line 405) | thread_control_monitor& threading_control::get_waiting_threads_mon...

FILE: third-party/tbb/src/tbb/threading_control.h
  type client_snapshot (line 52) | struct client_snapshot {
  function class (line 93) | class threading_control {

FILE: third-party/tbb/src/tbb/threading_control_client.h
  function namespace (line 22) | namespace tbb {

FILE: third-party/tbb/src/tbb/tls.h
  function namespace (line 28) | namespace tbb {

FILE: third-party/tbb/src/tbb/tools_api/ittnotify.h
  type __itt_collection_scope (line 340) | typedef enum {
  type __itt_pt_region (line 401) | typedef unsigned char __itt_pt_region;
  type __itt_suppress_mode_t (line 633) | typedef enum __itt_suppress_mode {
  type __itt_collection_state (line 642) | typedef enum {
  type __itt_model_disable (line 1093) | typedef enum {
  type __itt_domain (line 1814) | typedef struct ___itt_domain
  type __itt_id (line 1905) | typedef struct ___itt_id
  function ITTAPI (line 1927) | ITTAPI __itt_id_make(void* addr, unsigned long long extra)
  type __itt_string_handle (line 2003) | typedef struct ___itt_string_handle
  type __itt_timestamp (line 2085) | typedef unsigned long long __itt_timestamp;
  type __itt_scope (line 2398) | typedef enum
  type __itt_metadata_type (line 2460) | typedef enum {
  type __itt_relation (line 2675) | typedef enum
  type __itt_clock_info (line 2732) | typedef struct ___itt_clock_info
  type __itt_clock_domain (line 2748) | typedef struct ___itt_clock_domain
  type ___itt_counter (line 2934) | struct ___itt_counter
  type __itt_track_group_type (line 3357) | typedef enum ___itt_track_group_type
  type __itt_track_group (line 3366) | typedef struct ___itt_track_group
  type __itt_track_type (line 3383) | typedef enum ___itt_track_type
  type __itt_track (line 3394) | typedef struct ___itt_track
  type __itt_event (line 3476) | typedef int __itt_event;
  type __itt_av_data_type (line 3592) | typedef enum
  type __itt_module_type (line 3782) | typedef enum
  type __itt_section_type (line 3791) | typedef enum
  type __itt_section_info (line 3839) | typedef struct ___itt_section_info
  type __itt_module_object (line 3857) | typedef struct ___itt_module_object
  type __itt_histogram (line 3932) | typedef struct ___itt_histogram
  type __itt_context_type (line 4125) | typedef enum {
  type __itt_context_metadata (line 4161) | typedef struct ___itt_context_metadata
  type __itt_counter_metadata (line 4173) | typedef struct ___itt_counter_metadata
  type __itt_mark_type (line 4284) | typedef int __itt_mark_type;
  type ___itt_caller (line 4538) | struct ___itt_caller
  type __itt_error_code (line 4629) | typedef enum __itt_error_code

FILE: third-party/tbb/src/tbb/tools_api/ittnotify_config.h
  type HMODULE (line 259) | typedef HMODULE           lib_t;
  type DWORD (line 260) | typedef DWORD             TIDT;
  type CRITICAL_SECTION (line 261) | typedef CRITICAL_SECTION  mutex_t;
  type pthread_t (line 281) | typedef pthread_t         TIDT;
  type pthread_mutex_t (line 282) | typedef pthread_mutex_t   mutex_t;
  function __itt_interlocked_increment (line 306) | ITT_INLINE long __itt_interlocked_increment(volatile long* ptr)
  function __itt_interlocked_compare_exchange (line 312) | ITT_INLINE long
  function __TBB_machine_fetchadd4 (line 384) | ITT_INLINE long __TBB_machine_fetchadd4(volatile void* ptr, long addend)
  function __itt_interlocked_increment (line 399) | ITT_INLINE long __itt_interlocked_increment(volatile long* ptr)
  function __itt_interlocked_compare_exchange (line 405) | ITT_INLINE long
  type __itt_thread_state (line 444) | typedef enum {
  type __itt_thread_info (line 451) | typedef struct ___itt_thread_info
  type __itt_api_info_20101001 (line 468) | typedef struct ___itt_api_info_20101001
  type __itt_api_info (line 476) | typedef struct ___itt_api_info
  type __itt_counter_info_t (line 485) | typedef struct __itt_counter_info
  type ___itt_domain (line 506) | struct ___itt_domain
  type ___itt_string_handle (line 507) | struct ___itt_string_handle
  type ___itt_histogram (line 508) | struct ___itt_histogram
  type ___itt_counter_metadata (line 509) | struct ___itt_counter_metadata
  type __itt_global (line 513) | typedef struct ___itt_global

FILE: third-party/tbb/src/tbb/tools_api/ittnotify_static.c
  type __itt_group_alias (line 243) | typedef struct ___itt_group_alias
  function __itt_report_error (line 329) | static void __itt_report_error(int code, ...)
  function __itt_domain (line 353) | static __itt_domain* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(domain_createW),...
  function __itt_string_handle (line 477) | static __itt_string_handle* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(string_ha...
  function __itt_counter (line 569) | static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW)...
  function __itt_counter (line 612) | static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create),...
  function __itt_counter (line 666) | static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_t...
  function __itt_counter (line 708) | static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_t...
  function __itt_histogram (line 761) | static __itt_histogram* ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(histogram_cre...
  function __itt_counter (line 855) | static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_createW_...
  function __itt_counter (line 897) | static __itt_counter ITTAPI ITT_VERSIONIZE(ITT_JOIN(_N_(counter_create_v...
  function else (line 1007) | else if (type >= __itt_context_tid && type <= __itt_context_cpu_cycles_f...
  function __itt_group_id (line 1390) | static __itt_group_id __itt_get_groups(void)
  function __itt_lib_version (line 1439) | static int __itt_lib_version(lib_t lib)
  function __itt_nullify_all_pointers (line 1460) | static void __itt_nullify_all_pointers(void)
  function __itt_is_collector_available (line 1468) | static int __itt_is_collector_available(void)
  function ITT_EXTERN_C (line 1491) | ITT_EXTERN_C void _N_(fini_ittlib)(void)
  function __itt_free_allocated_resources (line 1529) | static void __itt_free_allocated_resources(void)
  function ITT_EXTERN_C (line 1600) | ITT_EXTERN_C int _N_(init_ittlib)(const char* lib_name, __itt_group_id i...
  function ITT_EXTERN_C (line 1734) | ITT_EXTERN_C __itt_error_handler_t* _N_(set_error_handler)(__itt_error_h...
  function ITT_EXTERN_C (line 1756) | ITT_EXTERN_C void _N_(mark_pt_region_begin)(__itt_pt_region region)
  function ITT_EXTERN_C (line 1772) | ITT_EXTERN_C void _N_(mark_pt_region_end)(__itt_pt_region region)
  function ITT_EXTERN_C (line 1788) | ITT_EXTERN_C __itt_collection_state (_N_(get_collection_state))(void)
  function ITT_EXTERN_C (line 1801) | ITT_EXTERN_C void (_N_(release_resources))(void)

FILE: third-party/tbb/src/tbb/tools_api/ittnotify_types.h
  type __itt_group_id (line 20) | typedef enum ___itt_group_id
  type __itt_group_list (line 46) | typedef struct ___itt_group_list

FILE: third-party/tbb/src/tbb/tools_api/legacy/ittnotify.h
  type __itt_event (line 625) | typedef int __itt_event;
  type __itt_state_t (line 805) | typedef int __itt_state_t;
  type __itt_obj_state_t (line 808) | typedef enum __itt_obj_state {
  type __itt_thr_state_t (line 815) | typedef enum __itt_thr_state {
  type __itt_obj_prop_t (line 821) | typedef enum __itt_obj_prop {
  type __itt_thr_prop_t (line 827) | typedef enum __itt_thr_prop {
  type __itt_frame_t (line 926) | struct __itt_frame_t

FILE: third-party/tbb/src/tbb/version.cpp
  function TBB_runtime_interface_version (line 19) | int TBB_runtime_interface_version() {

FILE: third-party/tbb/src/tbb/waiters.h
  function namespace (line 25) | namespace tbb {

FILE: third-party/tbb/src/tbbbind/tbb_bind.cpp
  type tbb (line 50) | namespace tbb {
    type detail (line 51) | namespace detail {
      type r1 (line 52) | namespace r1 {
        class system_topology (line 57) | class system_topology {
          type init_stages (line 76) | enum init_stages { uninitialized,
          method intergroup_binding_allowed (line 86) | bool intergroup_binding_allowed(std::size_t groups_num) { return...
          method topology_initialization (line 89) | void topology_initialization(std::size_t groups_num) {
          method numa_topology_parsing (line 135) | void numa_topology_parsing() {
          method core_types_topology_parsing (line 190) | void core_types_topology_parsing() {
          method processor_groups_topology_parsing (line 241) | void processor_groups_topology_parsing() {
          method enforce_hwloc_2_5_runtime_linkage (line 261) | void enforce_hwloc_2_5_runtime_linkage() {
          method initialize (line 274) | void initialize( std::size_t groups_num ) {
          method is_topology_parsed (line 298) | bool is_topology_parsed() { return initialization_state == topol...
          method construct (line 300) | static void construct( std::size_t groups_num ) {
          method system_topology (line 307) | static system_topology& instance() {
          method destroy (line 312) | static void destroy() {
          method fill_topology_information (line 342) | void fill_topology_information(
          method fill_constraints_affinity_mask (line 354) | void fill_constraints_affinity_mask(affinity_mask input_mask, in...
          method fit_num_threads_per_core (line 396) | void fit_num_threads_per_core(affinity_mask result_mask, affinit...
          method fit_to_processor_group (line 414) | void fit_to_processor_group(affinity_mask result_mask, affinity_...
          method get_default_concurrency (line 433) | int get_default_concurrency(int numa_node_index, int core_type_i...
          method affinity_mask (line 444) | affinity_mask allocate_process_affinity_mask() {
          method free_affinity_mask (line 449) | void free_affinity_mask( affinity_mask mask_to_free ) {
          method store_current_affinity_mask (line 453) | void store_current_affinity_mask( affinity_mask current_mask ) {
          method set_affinity_mask (line 461) | void set_affinity_mask( const_affinity_mask mask ) {
        class binding_handler (line 470) | class binding_handler {
          method binding_handler (line 485) | binding_handler( std::size_t size, int numa_node_id, int core_ty...
          method apply_affinity (line 515) | void apply_affinity( unsigned slot_num ) {
          method restore_previous_affinity_mask (line 547) | void restore_previous_affinity_mask( unsigned slot_num ) {
        function TBBBIND_EXPORT (line 558) | TBBBIND_EXPORT void __TBB_internal_initialize_system_topology(
        function TBBBIND_EXPORT (line 570) | TBBBIND_EXPORT binding_handler* __TBB_internal_allocate_binding_ha...
        function TBBBIND_EXPORT (line 575) | TBBBIND_EXPORT void __TBB_internal_deallocate_binding_handler(bind...
        function TBBBIND_EXPORT (line 580) | TBBBIND_EXPORT void __TBB_internal_apply_affinity(binding_handler*...
        function TBBBIND_EXPORT (line 585) | TBBBIND_EXPORT void __TBB_internal_restore_affinity(binding_handle...
        function TBBBIND_EXPORT (line 590) | TBBBIND_EXPORT int __TBB_internal_get_default_concurrency(int numa...
        function TBBBIND_EXPORT (line 594) | TBBBIND_EXPORT void __TBB_internal_destroy_system_topology() {

FILE: third-party/tbb/src/tbbmalloc/Customize.h
  function BitScanRev (line 50) | inline intptr_t BitScanRev(uintptr_t x) {
  function isAligned (line 55) | inline bool isAligned(T* arg, uintptr_t alignment) {
  function isPowerOfTwo (line 59) | static inline bool isPowerOfTwo(uintptr_t arg) {
  function isPowerOfTwoAtLeast (line 62) | static inline bool isPowerOfTwoAtLeast(uintptr_t arg, uintptr_t power2) {
  function do_yield (line 66) | inline void do_yield() {
  function namespace (line 85) | namespace rml {
  function namespace (line 93) | namespace tbb {
  type tbb (line 130) | typedef tbb::detail::d1::aggregator_generic<OperationType> type;
  type tbb (line 136) | typedef tbb::detail::d1::aggregated_operation<Derived> type;

FILE: third-party/tbb/src/tbbmalloc/MapMemory.h
  function UnmapMemory (line 151) | int UnmapMemory(void *area, size_t bytes)
  function UnmapMemory (line 170) | int UnmapMemory(void *area, size_t /*bytes*/)
  function UnmapMemory (line 193) | int UnmapMemory(void *area, size_t /*bytes*/)

FILE: third-party/tbb/src/tbbmalloc/Statistics.h
  type counter_type (line 21) | enum counter_type {
  type common_counter_type (line 37) | enum common_counter_type {
  type bin_counters (line 53) | struct bin_counters {
  function STAT_increment (line 59) | static inline int STAT_increment(int thread, int bin, int ctr)
  function initStatisticsCollection (line 64) | static inline void initStatisticsCollection() {
  function STAT_print (line 76) | static inline void STAT_print(int thread)

FILE: third-party/tbb/src/tbbmalloc/Synchronize.h
  function class (line 33) | class MallocMutex : tbb::detail::no_copy {
  function SpinWaitWhileEq (line 78) | inline void SpinWaitWhileEq(const std::atomic<intptr_t>& location, const...
  function SpinWaitUntilEq (line 84) | inline void SpinWaitUntilEq(const std::atomic<intptr_t>& location, const...
  function class (line 90) | class AtomicBackoff {

FILE: third-party/tbb/src/tbbmalloc/backend.cpp
  type rml (line 21) | namespace rml {
    type internal (line 22) | namespace internal {
      function freeRawMemory (line 46) | int freeRawMemory (void *object, size_t size) {
      class GuardedSize (line 157) | class GuardedSize : tbb::detail::no_copy {
        type State (line 160) | enum State {
        method initLocked (line 169) | void initLocked() { value.store(LOCKED, std::memory_order_release); }
        method makeCoalscing (line 170) | void makeCoalscing() {
        method tryLock (line 174) | size_t tryLock(State state) {
        method unlock (line 187) | void unlock(size_t size) {
        method isLastRegionBlock (line 192) | bool isLastRegionBlock() const { return value.load(std::memory_ord...
      type MemRegion (line 196) | struct MemRegion {
      class BlockMutexes (line 206) | class BlockMutexes {
      class FreeBlock (line 212) | class FreeBlock : BlockMutexes {
        method FreeBlock (line 226) | FreeBlock *rightNeig(size_t sz) const {
        method FreeBlock (line 230) | FreeBlock *leftNeig(size_t sz) const {
        method initHeader (line 235) | void initHeader() { myL.initLocked(); leftL.initLocked(); }
        method setMeFree (line 236) | void setMeFree(size_t size) { myL.unlock(size); }
        method trySetMeUsed (line 237) | size_t trySetMeUsed(GuardedSize::State s) { return myL.tryLock(s); }
        method isLastRegionBlock (line 238) | bool isLastRegionBlock() const { return myL.isLastRegionBlock(); }
        method setLeftFree (line 240) | void setLeftFree(size_t sz) { leftL.unlock(sz); }
        method trySetLeftUsed (line 241) | size_t trySetLeftUsed(GuardedSize::State s) { return leftL.tryLock...
        method tryLockBlock (line 243) | size_t tryLockBlock() {
        method markCoalescing (line 256) | void markCoalescing(size_t blockSz) {
        method markUsed (line 262) | void markUsed() {
        method markBlocks (line 267) | static void markBlocks(FreeBlock *fBlock, int num, size_t size) {
      type LastFreeBlock (line 278) | struct LastFreeBlock : public FreeBlock {
      class ITT_Guard (line 288) | class ITT_Guard {
        method ITT_Guard (line 291) | ITT_Guard(void *p) : ptr(p) {
      function FreeBlock (line 356) | FreeBlock *CoalRequestQ::getAll()
        method FreeBlock (line 226) | FreeBlock *rightNeig(size_t sz) const {
        method FreeBlock (line 230) | FreeBlock *leftNeig(size_t sz) const {
        method initHeader (line 235) | void initHeader() { myL.initLocked(); leftL.initLocked(); }
        method setMeFree (line 236) | void setMeFree(size_t size) { myL.unlock(size); }
        method trySetMeUsed (line 237) | size_t trySetMeUsed(GuardedSize::State s) { return myL.tryLock(s); }
        method isLastRegionBlock (line 238) | bool isLastRegionBlock() const { return myL.isLastRegionBlock(); }
        method setLeftFree (line 240) | void setLeftFree(size_t sz) { leftL.unlock(sz); }
        method trySetLeftUsed (line 241) | size_t trySetLeftUsed(GuardedSize::State s) { return leftL.tryLock...
        method tryLockBlock (line 243) | size_t tryLockBlock() {
        method markCoalescing (line 256) | void markCoalescing(size_t blockSz) {
        method markUsed (line 262) | void markUsed() {
        method markBlocks (line 267) | static void markBlocks(FreeBlock *fBlock, int num, size_t size) {
      function FreeBlock (line 386) | FreeBlock *Backend::IndexedBins::getFromBin(int binIdx, BackendSync ...
        method FreeBlock (line 226) | FreeBlock *rightNeig(size_t sz) const {
        method FreeBlock (line 230) | FreeBlock *leftNeig(size_t sz) const {
        method initHeader (line 235) | void initHeader() { myL.initLocked(); leftL.initLocked(); }
        method setMeFree (line 236) | void setMeFree(size_t size) { myL.unlock(size); }
        method trySetMeUsed (line 237) | size_t trySetMeUsed(GuardedSize::State s) { return myL.tryLock(s); }
        method isLastRegionBlock (line 238) | bool isLastRegionBlock() const { return myL.isLastRegionBlock(); }
        method setLeftFree (line 240) | void setLeftFree(size_t sz) { leftL.unlock(sz); }
        method trySetLeftUsed (line 241) | size_t trySetLeftUsed(GuardedSize::State s) { return leftL.tryLock...
        method tryLockBlock (line 243) | size_t tryLockBlock() {
        method markCoalescing (line 256) | void markCoalescing(size_t blockSz) {
        method markUsed (line 262) | void markUsed() {
        method markBlocks (line 267) | static void markBlocks(FreeBlock *fBlock, int num, size_t size) {
      function FreeBlock (line 573) | FreeBlock *Backend::splitBlock(FreeBlock *fBlock, int num, size_t si...
        method FreeBlock (line 226) | FreeBlock *rightNeig(size_t sz) const {
        method FreeBlock (line 230) | FreeBlock *leftNeig(size_t sz) const {
        method initHeader (line 235) | void initHeader() { myL.initLocked(); leftL.initLocked(); }
        method setMeFree (line 236) | void setMeFree(size_t size) { myL.unlock(size); }
        method trySetMeUsed (line 237) | size_t trySetMeUsed(GuardedSize::State s) { return myL.tryLock(s); }
        method isLastRegionBlock (line 238) | bool isLastRegionBlock() const { return myL.isLastRegionBlock(); }
        method setLeftFree (line 240) | void setLeftFree(size_t sz) { leftL.unlock(sz); }
        method trySetLeftUsed (line 241) | size_t trySetLeftUsed(GuardedSize::State s) { return leftL.tryLock...
        method tryLockBlock (line 243) | size_t tryLockBlock() {
        method markCoalescing (line 256) | void markCoalescing(size_t blockSz) {
        method markUsed (line 262) | void markUsed() {
        method markBlocks (line 267) | static void markBlocks(FreeBlock *fBlock, int num, size_t size) {
      function FreeBlock (line 637) | FreeBlock *Backend::releaseMemInCaches(intptr_t startModifiedCnt,
        method FreeBlock (line 226) | FreeBlock *rightNeig(size_t sz) const {
        method FreeBlock (line 230) | FreeBlock *leftNeig(size_t sz) const {
        method initHeader (line 235) | void initHeader() { myL.initLocked(); leftL.initLocked(); }
        method setMeFree (line 236) | void setMeFree(size_t size) { myL.unlock(size); }
        method trySetMeUsed (line 237) | size_t trySetMeUsed(GuardedSize::State s) { return myL.tryLock(s); }
        method isLastRegionBlock (line 238) | bool isLastRegionBlock() const { return myL.isLastRegionBlock(); }
        method setLeftFree (line 240) | void setLeftFree(size_t sz) { leftL.unlock(sz); }
        method trySetLeftUsed (line 241) | size_t trySetLeftUsed(GuardedSize::State s) { return leftL.tryLock...
        method tryLockBlock (line 243) | size_t tryLockBlock() {
        method markCoalescing (line 256) | void markCoalescing(size_t blockSz) {
        method markUsed (line 262) | void markUsed() {
        method markBlocks (line 267) | static void markBlocks(FreeBlock *fBlock, int num, size_t size) {
      function FreeBlock (line 655) | FreeBlock *Backend::askMemFromOS(size_t blockSize, intptr_t startMod...
        method FreeBlock (line 226) | FreeBlock *rightNeig(size_t sz) const {
        method FreeBlock (line 230) | FreeBlock *leftNeig(size_t sz) const {
        method initHeader (line 235) | void initHeader() { myL.initLocked(); leftL.initLocked(); }
        method setMeFree (line 236) | void setMeFree(size_t size) { myL.unlock(size); }
        method trySetMeUsed (line 237) | size_t trySetMeUsed(GuardedSize::State s) { return myL.tryLock(s); }
        method isLastRegionBlock (line 238) | bool isLastRegionBlock() const { return myL.isLastRegionBlock(); }
        method setLeftFree (line 240) | void setLeftFree(size_t sz) { leftL.unlock(sz); }
        method trySetLeftUsed (line 241) | size_t trySetLeftUsed(GuardedSize::State s) { return leftL.tryLock...
        method tryLockBlock (line 243) | size_t tryLockBlock() {
        method markCoalescing (line 256) | void markCoalescing(size_t blockSz) {
        method markUsed (line 262) | void markUsed() {
        method markBlocks (line 267) | static void markBlocks(FreeBlock *fBlock, int num, size_t size) {
      function FreeBlock (line 762) | FreeBlock *Backend::IndexedBins::findBlock(int nativeBin, BackendSyn...
        method FreeBlock (line 226) | FreeBlock *rightNeig(size_t sz) const {
        method FreeBlock (line 230) | FreeBlock *leftNeig(size_t sz) const {
        method initHeader (line 235) | void initHeader() { myL.initLocked(); leftL.initLocked(); }
        method setMeFree (line 236) | void setMeFree(size_t size) { myL.unlock(size); }
        method trySetMeUsed (line 237) | size_t trySetMeUsed(GuardedSize::State s) { return myL.tryLock(s); }
        method isLastRegionBlock (line 238) | bool isLastRegionBlock() const { return myL.isLastRegionBlock(); }
        method setLeftFree (line 240) | void setLeftFree(size_t sz) { leftL.unlock(sz); }
        method trySetLeftUsed (line 241) | size_t trySetLeftUsed(GuardedSize::State s) { return leftL.tryLock...
        method tryLockBlock (line 243) | size_t tryLockBlock() {
        method markCoalescing (line 256) | void markCoalescing(size_t blockSz) {
        method markUsed (line 262) | void markUsed() {
        method markBlocks (line 267) | static void markBlocks(FreeBlock *fBlock, int num, size_t size) {
      function FreeBlock (line 789) | FreeBlock *Backend::genericGetBlock(int num, size_t size, bool needA...
        method FreeBlock (line 226) | FreeBlock *rightNeig(size_t sz) const {
        method FreeBlock (line 230) | FreeBlock *leftNeig(size_t sz) const {
        method initHeader (line 235) | void initHeader() { myL.initLocked(); leftL.initLocked(); }
        method setMeFree (line 236) | void setMeFree(size_t size) { myL.unlock(size); }
        method trySetMeUsed (line 237) | size_t trySetMeUsed(GuardedSize::State s) { return myL.tryLock(s); }
        method isLastRegionBlock (line 238) | bool isLastRegionBlock() const { return myL.isLastRegionBlock(); }
        method setLeftFree (line 240) | void setLeftFree(size_t sz) { leftL.unlock(sz); }
        method trySetLeftUsed (line 241) | size_t trySetLeftUsed(GuardedSize::State s) { return leftL.tryLock...
        method tryLockBlock (line 243) | size_t tryLockBlock() {
        method markCoalescing (line 256) | void markCoalescing(size_t blockSz) {
        method markUsed (line 262) | void markUsed() {
        method markBlocks (line 267) | static void markBlocks(FreeBlock *fBlock, int num, size_t size) {
      function LargeMemoryBlock (line 862) | LargeMemoryBlock *Backend::getLargeBlock(size_t size)
      function BlockI (line 874) | BlockI *Backend::getSlabBlock(int num) {
      function FreeBlock (line 1042) | FreeBlock *Backend::doCoalesc(FreeBlock *fBlock, MemRegion **mRegion)
        method FreeBlock (line 226) | FreeBlock *rightNeig(size_t sz) const {
        method FreeBlock (line 230) | FreeBlock *leftNeig(size_t sz) const {
        method initHeader (line 235) | void initHeader() { myL.initLocked(); leftL.initLocked(); }
        method setMeFree (line 236) | void setMeFree(size_t size) { myL.unlock(size); }
        method trySetMeUsed (line 237) | size_t trySetMeUsed(GuardedSize::State s) { return myL.tryLock(s); }
        method isLastRegionBlock (line 238) | bool isLastRegionBlock() const { return myL.isLastRegionBlock(); }
        method setLeftFree (line 240) | void setLeftFree(size_t sz) { leftL.unlock(sz); }
        method trySetLeftUsed (line 241) | size_t trySetLeftUsed(GuardedSize::State s) { return leftL.tryLock...
        method tryLockBlock (line 243) | size_t tryLockBlock() {
        method markCoalescing (line 256) | void markCoalescing(size_t blockSz) {
        method markUsed (line 262) | void markUsed() {
        method markBlocks (line 267) | static void markBlocks(FreeBlock *fBlock, int num, size_t size) {
      function FreeBlock (line 1227) | FreeBlock *Backend::findBlockInRegion(MemRegion *region, size_t exac...
        method FreeBlock (line 226) | FreeBlock *rightNeig(size_t sz) const {
        method FreeBlock (line 230) | FreeBlock *leftNeig(size_t sz) const {
        method initHeader (line 235) | void initHeader() { myL.initLocked(); leftL.initLocked(); }
        method setMeFree (line 236) | void setMeFree(size_t size) { myL.unlock(size); }
        method trySetMeUsed (line 237) | size_t trySetMeUsed(GuardedSize::State s) { return myL.tryLock(s); }
        method isLastRegionBlock (line 238) | bool isLastRegionBlock() const { return myL.isLastRegionBlock(); }
        method setLeftFree (line 240) | void setLeftFree(size_t sz) { leftL.unlock(sz); }
        method trySetLeftUsed (line 241) | size_t trySetLeftUsed(GuardedSize::State s) { return leftL.tryLock...
        method tryLockBlock (line 243) | size_t tryLockBlock() {
        method markCoalescing (line 256) | void markCoalescing(size_t blockSz) {
        method markUsed (line 262) | void markUsed() {
        method markBlocks (line 267) | static void markBlocks(FreeBlock *fBlock, int num, size_t size) {
      function FreeBlock (line 1331) | FreeBlock *Backend::addNewRegion(size_t size, MemRegionType memRegTy...
        method FreeBlock (line 226) | FreeBlock *rightNeig(size_t sz) const {
        method FreeBlock (line 230) | FreeBlock *leftNeig(size_t sz) const {
        method initHeader (line 235) | void initHeader() { myL.initLocked(); leftL.initLocked(); }
        method setMeFree (line 236) | void setMeFree(size_t size) { myL.unlock(size); }
        method trySetMeUsed (line 237) | size_t trySetMeUsed(GuardedSize::State s) { return myL.tryLock(s); }
        method isLastRegionBlock (line 238) | bool isLastRegionBlock() const { return myL.isLastRegionBlock(); }
        method setLeftFree (line 240) | void setLeftFree(size_t sz) { leftL.unlock(sz); }
        method trySetLeftUsed (line 241) | size_t trySetLeftUsed(GuardedSize::State s) { return leftL.tryLock...
        method tryLockBlock (line 243) | size_t tryLockBlock() {
        method markCoalescing (line 256) | void markCoalescing(size_t blockSz) {
        method markUsed (line 262) | void markUsed() {
        method markBlocks (line 267) | static void markBlocks(FreeBlock *fBlock, int num, size_t size) {

FILE: third-party/tbb/src/tbbmalloc/backend.h
  function class (line 27) | class BackendSync {
  function blockConsumed (line 35) | void blockConsumed() { inFlyBlocks++; }
  function binsModified (line 36) | void binsModified() { binsModifications++; }
  function blockReleased (line 37) | void blockReleased() {
  function class (line 51) | class CoalRequestQ { // queue of free blocks that coalescing was delayed
  function class (line 66) | class MemExtendingSema {
  type MemRegionType (line 90) | enum MemRegionType {
  function class (line 99) | class MemRegionList {
  function class (line 108) | class Backend {

FILE: third-party/tbb/src/tbbmalloc/backref.cpp
  type rml (line 20) | namespace rml {
    type internal (line 21) | namespace internal {
      type BackRefBlock (line 28) | struct BackRefBlock : public BlockI {
        method BackRefBlock (line 41) | BackRefBlock(const BackRefBlock *blockToUse, intptr_t num) :
        method zeroSet (line 51) | void zeroSet() { memset(static_cast<void*>(this+1), 0, BackRefBloc...
      type BackRefMain (line 58) | struct BackRefMain {
      function initBackRefMain (line 96) | bool initBackRefMain(Backend *backend)
      function destroyBackRefMain (line 125) | void destroyBackRefMain(Backend *backend)
      function BackRefBlock (line 210) | BackRefBlock *BackRefMain::findFreeBlock()
        method BackRefBlock (line 41) | BackRefBlock(const BackRefBlock *blockToUse, intptr_t num) :
        method zeroSet (line 51) | void zeroSet() { memset(static_cast<void*>(this+1), 0, BackRefBloc...
      function setBackRef (line 253) | void setBackRef(BackRefIdx backRefIdx, void *newPtr)
      function BackRefIdx (line 261) | BackRefIdx BackRefIdx::newBackRef(bool largeObj)
      function removeBackRef (line 320) | void removeBackRef(BackRefIdx backRefIdx)

FILE: third-party/tbb/src/tbbmalloc/frontend.cpp
  type rml (line 56) | namespace rml {
    class MemoryPool (line 57) | class MemoryPool
    type internal (line 58) | namespace internal {
      class Block (line 60) | class Block
        method empty (line 356) | bool empty() const {
        method freeListNonNull (line 367) | bool freeListNonNull() { return freeList; }
        method getSize (line 377) | unsigned int getSize() const {
        method BackRefIdx (line 382) | const BackRefIdx *getBackRefIdx() const { return &backRefIdx; }
        method isStartupAllocObject (line 384) | bool isStartupAllocObject() const { return objectSize == startupAl...
        method checkFreePrecond (line 386) | void checkFreePrecond(const void *object) const {
        method MemoryPool (line 422) | MemoryPool *getMemPool() const { return poolPtr; }
        method markOwned (line 435) | inline void markOwned(TLSData *tls) {
        method markOrphaned (line 440) | inline void markOrphaned() {
      class MemoryPool (line 61) | class MemoryPool
        method MemoryPool (line 266) | MemoryPool() = delete;
        method clearTLS (line 285) | void clearTLS() { extMemPool.tlsPointerKey.setThreadMallocTLS(null...
      function isSolidPtr (line 71) | inline bool isSolidPtr( void* ptr ) {
      function isNotForUse (line 74) | inline bool isNotForUse( void* ptr ) {
      class BootStrapBlocks (line 97) | class BootStrapBlocks {
      class ThreadId (line 109) | class ThreadId {
        method tlsNumber (line 115) | static unsigned int tlsNumber() {
        method init (line 127) | static bool init() {
        method destroy (line 142) | static void destroy() {
        method ThreadId (line 156) | ThreadId() : id(ThreadId::tlsNumber()) {}
        method isCurrentThreadId (line 157) | bool isCurrentThreadId() const { return id == ThreadId::tlsNumber(...
        method getThreadId (line 160) | unsigned int getThreadId() { return ThreadId::tlsNumber(); }
        method getMaxThreadId (line 163) | static unsigned getMaxThreadId() { return ThreadCount.load(std::me...
        method ThreadId (line 188) | ThreadId() : tid(GetMyTID()) {}
        method ThreadId (line 189) | ThreadId(ThreadId &other) = delete;
        method isCurrentThreadId (line 193) | bool isCurrentThreadId() const { return pthread_equal(pthread_self...
        method isCurrentThreadId (line 195) | bool isCurrentThreadId() const { return GetCurrentThreadId() == ti...
        method ThreadId (line 197) | ThreadId& operator=(const ThreadId& other) {
        method init (line 201) | static bool init() { return true; }
        method destroy (line 203) | static void destroy() {}
      function STAT_increment (line 173) | int STAT_increment(ThreadId tid, int bin, int ctr)
      class ThreadId (line 181) | class ThreadId {
        method tlsNumber (line 115) | static unsigned int tlsNumber() {
        method init (line 127) | static bool init() {
        method destroy (line 142) | static void destroy() {
        method ThreadId (line 156) | ThreadId() : id(ThreadId::tlsNumber()) {}
        method isCurrentThreadId (line 157) | bool isCurrentThreadId() const { return id == ThreadId::tlsNumber(...
        method getThreadId (line 160) | unsigned int getThreadId() { return ThreadId::tlsNumber(); }
        method getMaxThreadId (line 163) | static unsigned getMaxThreadId() { return ThreadCount.load(std::me...
        method ThreadId (line 188) | ThreadId() : tid(GetMyTID()) {}
        method ThreadId (line 189) | ThreadId(ThreadId &other) = delete;
        method isCurrentThreadId (line 193) | bool isCurrentThreadId() const { return pthread_equal(pthread_self...
        method isCurrentThreadId (line 195) | bool isCurrentThreadId() const { return GetCurrentThreadId() == ti...
        method ThreadId (line 197) | ThreadId& operator=(const ThreadId& other) {
        method init (line 201) | static bool init() { return true; }
        method destroy (line 203) | static void destroy() {}
      function TLSData (line 236) | inline TLSData* TLSKey::getThreadMallocTLS() const
        method TLSData (line 596) | TLSData(MemoryPool *mPool, Backend *bknd) : memPool(mPool), freeSl...
        method MemoryPool (line 597) | MemoryPool *getMemPool() const { return memPool; }
        method externalCleanup (line 600) | bool externalCleanup(bool cleanOnlyUnused, bool cleanBins) {
        method markUsed (line 611) | void markUsed() { unused.store(false, std::memory_order_relaxed); }
        method markUnused (line 612) | void markUnused() { unused.store(true, std::memory_order_relaxed); }
      class Bin (line 258) | class Bin
        method Block (line 464) | inline Block* getActiveBlock() const { return activeBlk; }
        method resetActiveBlock (line 465) | void resetActiveBlock() { activeBlk = nullptr; }
        method verifyInitState (line 479) | void verifyInitState() const {
      class StartupBlock (line 259) | class StartupBlock
        method availableSize (line 1839) | size_t availableSize() const {
        method msize (line 1845) | static size_t msize(void *ptr) { return *((size_t*)ptr - 1); }
      class MemoryPool (line 261) | class MemoryPool {
        method MemoryPool (line 266) | MemoryPool() = delete;
        method clearTLS (line 285) | void clearTLS() { extMemPool.tlsPointerKey.setThreadMallocTLS(null...
      type PaddingImpl (line 307) | struct PaddingImpl {
      type PaddingImpl<0> (line 312) | struct PaddingImpl<0> {}
      type Padding (line 315) | struct Padding : PaddingImpl<N/sizeof(size_t)> {}
      class GlobalBlockFields (line 319) | class GlobalBlockFields : public BlockI {
      class LocalBlockFields (line 326) | class LocalBlockFields : public GlobalBlockFields, Padding<blockHead...
      class Block (line 353) | class Block : public LocalBlockFields,
        method empty (line 356) | bool empty() const {
        method freeListNonNull (line 367) | bool freeListNonNull() { return freeList; }
        method getSize (line 377) | unsigned int getSize() const {
        method BackRefIdx (line 382) | const BackRefIdx *getBackRefIdx() const { return &backRefIdx; }
        method isStartupAllocObject (line 384) | bool isStartupAllocObject() const { return objectSize == startupAl...
        method checkFreePrecond (line 386) | void checkFreePrecond(const void *object) const {
        method MemoryPool (line 422) | MemoryPool *getMemPool() const { return poolPtr; }
        method markOwned (line 435) | inline void markOwned(TLSData *tls) {
        method markOrphaned (line 440) | inline void markOrphaned() {
      class Bin (line 456) | class Bin {
        method Block (line 464) | inline Block* getActiveBlock() const { return activeBlk; }
        method resetActiveBlock (line 465) | void resetActiveBlock() { activeBlk = nullptr; }
        method verifyInitState (line 479) | void verifyInitState() const {
      class FreeBlockPool (line 538) | class FreeBlockPool {
        class ResOfGet (line 547) | class ResOfGet {
          method ResOfGet (line 548) | ResOfGet() = delete;
          method ResOfGet (line 552) | ResOfGet(Block *b, bool lastMiss) : block(b), lastAccMiss(lastMi...
        method FreeBlockPool (line 556) | FreeBlockPool(Backend *bknd) : backend(bknd) {}
      class LocalLOCImpl (line 563) | class LocalLOCImpl {
        method LocalLOCImpl (line 576) | LocalLOCImpl() : tail(nullptr), head(nullptr), totalSize(0), numOf...
        method getMaxSize (line 577) | static size_t getMaxSize() { return MAX_TOTAL_SIZE; }
      class TLSData (line 586) | class TLSData : public TLSRemote {
        method TLSData (line 596) | TLSData(MemoryPool *mPool, Backend *bknd) : memPool(mPool), freeSl...
        method MemoryPool (line 597) | MemoryPool *getMemPool() const { return memPool; }
        method externalCleanup (line 600) | bool externalCleanup(bool cleanOnlyUnused, bool cleanBins) {
        method markUsed (line 611) | void markUsed() { unused.store(false, std::memory_order_relaxed); }
        method markUnused (line 612) | void markUnused() { unused.store(true, std::memory_order_relaxed); }
      function TLSData (line 615) | TLSData *TLSKey::createTLS(MemoryPool *memPool, Backend *backend)
        method TLSData (line 596) | TLSData(MemoryPool *mPool, Backend *bknd) : memPool(mPool), freeSl...
        method MemoryPool (line 597) | MemoryPool *getMemPool() const { return memPool; }
        method externalCleanup (line 600) | bool externalCleanup(bool cleanOnlyUnused, bool cleanBins) {
        method markUsed (line 611) | void markUsed() { unused.store(false, std::memory_order_relaxed); }
        method markUnused (line 612) | void markUnused() { unused.store(true, std::memory_order_relaxed); }
      type MemoryOrigin (line 723) | enum MemoryOrigin {
      function highestBitPos (line 773) | static inline unsigned int highestBitPos(unsigned int n)
      function getSmallObjectIndex (line 806) | unsigned int getSmallObjectIndex(unsigned int size)
      function getIndexOrObjectSize (line 823) | static unsigned int getIndexOrObjectSize (unsigned int size)
      function getIndex (line 864) | static unsigned int getIndex (unsigned int size)
      function getObjectSize (line 869) | static unsigned int getObjectSize (unsigned int size)
      function Block (line 946) | Block *LifoList::pop()
        method empty (line 356) | bool empty() const {
        method freeListNonNull (line 367) | bool freeListNonNull() { return freeList; }
        method getSize (line 377) | unsigned int getSize() const {
        method BackRefIdx (line 382) | const BackRefIdx *getBackRefIdx() const { return &backRefIdx; }
        method isStartupAllocObject (line 384) | bool isStartupAllocObject() const { return objectSize == startupAl...
        method checkFreePrecond (line 386) | void checkFreePrecond(const void *object) const {
        method MemoryPool (line 422) | MemoryPool *getMemPool() const { return poolPtr; }
        method markOwned (line 435) | inline void markOwned(TLSData *tls) {
        method markOrphaned (line 440) | inline void markOrphaned() {
      function Block (line 959) | Block *LifoList::grab()
        method empty (line 356) | bool empty() const {
        method freeListNonNull (line 367) | bool freeListNonNull() { return freeList; }
        method getSize (line 377) | unsigned int getSize() const {
        method BackRefIdx (line 382) | const BackRefIdx *getBackRefIdx() const { return &backRefIdx; }
        method isStartupAllocObject (line 384) | bool isStartupAllocObject() const { return objectSize == startupAl...
        method checkFreePrecond (line 386) | void checkFreePrecond(const void *object) const {
        method MemoryPool (line 422) | MemoryPool *getMemPool() const { return poolPtr; }
        method markOwned (line 435) | inline void markOwned(TLSData *tls) {
        method markOrphaned (line 440) | inline void markOrphaned() {
      function TLSData (line 991) | TLSData* MemoryPool::getTLS(bool create)
        method TLSData (line 596) | TLSData(MemoryPool *mPool, Backend *bknd) : memPool(mPool), freeSl...
        method MemoryPool (line 597) | MemoryPool *getMemPool() const { return memPool; }
        method externalCleanup (line 600) | bool externalCleanup(bool cleanOnlyUnused, bool cleanBins) {
        method markUsed (line 611) | void markUsed() { unused.store(false, std::memory_order_relaxed); }
        method markUnused (line 612) | void markUnused() { unused.store(true, std::memory_order_relaxed); }
      function Bin (line 1002) | inline Bin* TLSData::getAllocationBin(size_t size)
        method Block (line 464) | inline Block* getActiveBlock() const { return activeBlk; }
        method resetActiveBlock (line 465) | void resetActiveBlock() { activeBlk = nullptr; }
        method verifyInitState (line 479) | void verifyInitState() const {
      function Block (line 1008) | Block *MemoryPool::getEmptyBlock(size_t size)
        method empty (line 356) | bool empty() const {
        method freeListNonNull (line 367) | bool freeListNonNull() { return freeList; }
        method getSize (line 377) | unsigned int getSize() const {
        method BackRefIdx (line 382) | const BackRefIdx *getBackRefIdx() const { return &backRefIdx; }
        method isStartupAllocObject (line 384) | bool isStartupAllocObject() const { return objectSize == startupAl...
        method checkFreePrecond (line 386) | void checkFreePrecond(const void *object) const {
        method MemoryPool (line 422) | MemoryPool *getMemPool() const { return poolPtr; }
        method markOwned (line 435) | inline void markOwned(TLSData *tls) {
        method markOrphaned (line 440) | inline void markOrphaned() {
      function Block (line 1267) | Block* Bin::getPrivatizedFreeListBlock()
        method empty (line 356) | bool empty() const {
        method freeListNonNull (line 367) | bool freeListNonNull() { return freeList; }
        method getSize (line 377) | unsigned int getSize() const {
        method BackRefIdx (line 382) | const BackRefIdx *getBackRefIdx() const { return &backRefIdx; }
        method isStartupAllocObject (line 384) | bool isStartupAllocObject() const { return objectSize == startupAl...
        method checkFreePrecond (line 386) | void checkFreePrecond(const void *object) const {
        method MemoryPool (line 422) | MemoryPool *getMemPool() const { return poolPtr; }
        method markOwned (line 435) | inline void markOwned(TLSData *tls) {
        method markOrphaned (line 440) | inline void markOrphaned() {
      function Block (line 1598) | Block *OrphanedBlocks::get(TLSData *tls, unsigned int size)
        method empty (line 356) | bool empty() const {
        method freeListNonNull (line 367) | bool freeListNonNull() { return freeList; }
        method getSize (line 377) | unsigned int getSize() const {
        method BackRefIdx (line 382) | const BackRefIdx *getBackRefIdx() const { return &backRefIdx; }
        method isStartupAllocObject (line 384) | bool isStartupAllocObject() const { return objectSize == startupAl...
        method checkFreePrecond (line 386) | void checkFreePrecond(const void *object) const {
        method MemoryPool (line 422) | MemoryPool *getMemPool() const { return poolPtr; }
        method markOwned (line 435) | inline void markOwned(TLSData *tls) {
        method markOrphaned (line 440) | inline void markOrphaned() {
      function Block (line 1738) | inline Block* Bin::setPreviousBlockActive()
        method empty (line 356) | bool empty() const {
        method freeListNonNull (line 367) | bool freeListNonNull() { return freeList; }
        method getSize (line 377) | unsigned int getSize() const {
        method BackRefIdx (line 382) | const BackRefIdx *getBackRefIdx() const { return &backRefIdx; }
        method isStartupAllocObject (line 384) | bool isStartupAllocObject() const { return objectSize == startupAl...
        method checkFreePrecond (line 386) | void checkFreePrecond(const void *object) const {
        method MemoryPool (line 422) | MemoryPool *getMemPool() const { return poolPtr; }
        method markOwned (line 435) | inline void markOwned(TLSData *tls) {
        method markOrphaned (line 440) | inline void markOrphaned() {
      function FreeObject (line 1753) | FreeObject *Block::findObjectToFree(const void *object) const
      class StartupBlock (line 1838) | class StartupBlock : public Block {
        method availableSize (line 1839) | size_t availableSize() const {
        method msize (line 1845) | static size_t msize(void *ptr) { return *((size_t*)ptr - 1); }
      function StartupBlock (line 1852) | StartupBlock *StartupBlock::getBlock()
        method availableSize (line 1839) | size_t availableSize() const {
        method msize (line 1845) | static size_t msize(void *ptr) { return *((size_t*)ptr - 1); }
      function FreeObject (line 1870) | FreeObject *StartupBlock::allocate(size_t size)
      class ShutdownSync (line 1962) | class ShutdownSync {
        method init (line 1969) | void init() { flag.store(0, std::memory_order_release); }
        method threadDtorStart (line 1972) | bool threadDtorStart() {
        method threadDtorDone (line 1981) | void threadDtorDone() {
        method processExit (line 1984) | void processExit() {
        method init (line 1995) | void init() { }
        method threadDtorStart (line 1996) | bool threadDtorStart() { return true; }
        method threadDtorDone (line 1997) | void threadDtorDone() { }
        method processExit (line 1998) | void processExit() { }
      class ShutdownSync (line 1993) | class ShutdownSync {
        method init (line 1969) | void init() { flag.store(0, std::memory_order_release); }
        method threadDtorStart (line 1972) | bool threadDtorStart() {
        method threadDtorDone (line 1981) | void threadDtorDone() {
        method processExit (line 1984) | void processExit() {
        method init (line 1995) | void init() { }
        method threadDtorStart (line 1996) | bool threadDtorStart() { return true; }
        method threadDtorDone (line 1997) | void threadDtorDone() { }
        method processExit (line 1998) | void processExit() { }
      function isMallocInitialized (line 2005) | inline bool isMallocInitialized() {
      function MallocInitializeITT (line 2012) | void MallocInitializeITT() {
      function initMemoryManager (line 2027) | static bool initMemoryManager()
      function GetBoolEnvironmentVariable (line 2063) | static bool GetBoolEnvironmentVariable(const char* name) {
      function doInitialization (line 2070) | static bool doInitialization()
      function FreeObject (line 2107) | FreeObject *Block::allocateFromFreeList()
      function FreeObject (line 2124) | FreeObject *Block::allocateFromBumpPtr()
      function FreeObject (line 2139) | inline FreeObject* Block::allocate()
      function LargeMemoryBlock (line 2238) | LargeMemoryBlock *LocalLOCImpl<LOW_MARK, HIGH_MARK>::get(size_t size)
      function FreeObject (line 2465) | FreeObject *Block::findAllocatedObject(const void *address) const
      function BackRefIdx (line 2480) | static inline BackRefIdx safer_dereference (const BackRefIdx *ptr)
      function isLargeObject (line 2497) | bool isLargeObject(void *object)
      function isSmallObject (line 2514) | static inline bool isSmallObject (void *ptr)
      function isRecognized (line 2526) | static inline bool isRecognized (void* ptr)
      function freeSmallObject (line 2532) | static inline void freeSmallObject(void *object)
      function internalPoolFree (line 2634) | static bool internalPoolFree(MemoryPool *memPool, void *object, size...
      function internalFree (line 2668) | static void internalFree(void *object)
      function internalMsize (line 2673) | static size_t internalMsize(void* ptr)
    function TBBMALLOC_EXPORT (line 2692) | TBBMALLOC_EXPORT rml::MemoryPool *pool_create(intptr_t pool_id, const ...
    function pool_create_v1 (line 2701) | rml::MemPoolError pool_create_v1(intptr_t pool_id, const MemPoolPolicy...
    function pool_destroy (line 2739) | bool pool_destroy(rml::MemoryPool* memPool)
    function pool_reset (line 2748) | bool pool_reset(rml::MemoryPool* memPool)
    function pool_free (line 2797) | bool pool_free(rml::MemoryPool *mPool, void *object)
    function pool_msize (line 2818) | size_t pool_msize(rml::MemoryPool *mPool, void* object)
  function doThreadShutdownNotification (line 2855) | void doThreadShutdownNotification(TLSData* tls, bool main_thread)
  function mallocThreadShutdownNotification (line 2888) | void mallocThreadShutdownNotification(void* arg)
  function __TBB_mallocThreadShutdownNotification (line 2895) | void __TBB_mallocThreadShutdownNotification()
  function __TBB_mallocProcessShutdownNotification (line 2903) | void __TBB_mallocProcessShutdownNotification(bool windows_process_dying)
  function scalable_free (line 2948) | void scalable_free(void *object)
  function TBBMALLOC_EXPORT (line 2954) | TBBMALLOC_EXPORT void __TBB_malloc_free_definite_size(void *object, size...
  function TBBMALLOC_EXPORT (line 2964) | TBBMALLOC_EXPORT void __TBB_malloc_safer_free(void *object, void (*origi...
  function TBBMALLOC_EXPORT (line 3019) | TBBMALLOC_EXPORT void* __TBB_malloc_safer_realloc(void* ptr, size_t sz, ...
  function scalable_posix_memalign (line 3098) | int scalable_posix_memalign(void **memptr, size_t alignment, size_t size)
  function TBBMALLOC_EXPORT (line 3140) | TBBMALLOC_EXPORT void * __TBB_malloc_safer_aligned_realloc(void *ptr, si...
  function scalable_aligned_free (line 3192) | void scalable_aligned_free(void *ptr)
  function scalable_msize (line 3204) | size_t scalable_msize(void* ptr)
  function TBBMALLOC_EXPORT (line 3220) | TBBMALLOC_EXPORT size_t __TBB_malloc_safer_msize(void *object, size_t (*...
  function TBBMALLOC_EXPORT (line 3239) | TBBMALLOC_EXPORT size_t __TBB_malloc_safer_aligned_msize(void *object, s...
  function scalable_allocation_mode (line 3255) | int scalable_allocation_mode(int param, intptr_t value)
  function scalable_allocation_command (line 3291) | int scalable_allocation_command(int cmd, void *param)

FILE: third-party/tbb/src/tbbmalloc/large_objects.cpp
  type rml (line 29) | namespace rml {
    type internal (line 30) | namespace internal {
      class CacheBinFunctor (line 73) | class CacheBinFunctor {
        class OperationPreprocessor (line 90) | class OperationPreprocessor {
          method OperationPreprocessor (line 125) | OperationPreprocessor(typename LargeObjectCacheImpl<Props>::Cach...
          method getTimeRange (line 129) | uintptr_t getTimeRange() const { return -lclTime; }
        method CacheBinFunctor (line 135) | CacheBinFunctor(typename LargeObjectCacheImpl<Props>::CacheBin *bi...
        method isCleanupNeeded (line 140) | bool isCleanupNeeded() const { return needCleanup; }
        method LargeMemoryBlock (line 141) | LargeMemoryBlock *getToRelease() const { return toRelease; }
        method getCurrTime (line 142) | uintptr_t getCurrTime() const { return currTime; }
      type OpGet (line 148) | struct OpGet {
      type OpPutList (line 155) | struct OpPutList {
      type OpCleanToThreshold (line 160) | struct OpCleanToThreshold {
      type OpCleanAll (line 166) | struct OpCleanAll {
      type OpUpdateUsedSize (line 171) | struct OpUpdateUsedSize {
      type CacheBinOperation (line 189) | struct CacheBinOperation : public MallocAggregatedOperation<CacheBin...
        method CacheBinOperation (line 193) | CacheBinOperation(OpTypeData &d, CacheBinOperationStatus st = CBST...
      function OpTypeData (line 212) | OpTypeData& opCast(CacheBinOperation &op) {
      function lessThanWithOverflow (line 226) | inline bool lessThanWithOverflow(intptr_t a, intptr_t b)
      function LargeMemoryBlock (line 461) | LargeMemoryBlock *LargeObjectCacheImpl<Props>::
      function LargeMemoryBlock (line 538) | LargeMemoryBlock *LargeObjectCacheImpl<Props>::
      function LargeMemoryBlock (line 583) | LargeMemoryBlock *LargeObjectCacheImpl<Props>::
      function LargeMemoryBlock (line 625) | LargeMemoryBlock *LargeObjectCacheImpl<Props>::
      function LargeMemoryBlock (line 667) | LargeMemoryBlock *LargeObjectCacheImpl<Props>::
      function LargeMemoryBlock (line 837) | LargeMemoryBlock *LargeObjectCacheImpl<Props>::get(ExtMemoryPool *ex...
      function LargeMemoryBlock (line 970) | LargeMemoryBlock *LargeObjectCache::get(size_t size)
      function LargeMemoryBlock (line 980) | LargeMemoryBlock *ExtMemoryPool::mallocLargeObject(MemoryPool *pool,...

FILE: third-party/tbb/src/tbbmalloc/large_objects.h
  type CacheBinOperationType (line 26) | enum CacheBinOperationType {
  type CacheBinOperationStatus (line 37) | enum CacheBinOperationStatus {
  function alignToBin (line 53) | static size_t alignToBin(size_t size) {
  function sizeToIdx (line 57) | static int sizeToIdx(size_t size) {
  function alignToBin (line 82) | static size_t alignToBin(size_t size) {
  function sizeToIdx (line 94) | static int sizeToIdx(size_t size) {
  function update (line 137) | void update(size_t usedSize, size_t cachedSize) {
  function reset (line 141) | void reset() { usedSz = cachedSz = 0; }
  type BitMaskMax (line 148) | typedef BitMaskMax<numBins> BinBitMask;
  function class (line 155) | class CacheBin {
  function sizeToIdx (line 261) | static int sizeToIdx(size_t size) {
  function class (line 284) | class LargeObjectCache {

FILE: third-party/tbb/src/tbbmalloc/shared_utils.h
  function T (line 38) | inline T alignDown(T arg, uintptr_t alignment) {
  function T (line 42) | inline T alignUp  (T arg, uintptr_t alignment) {
  function T (line 47) | inline T alignUpGeneric(T arg, uintptr_t alignment) {
  type Log2 (line 60) | struct Log2
  type parseFileItem (line 91) | struct parseFileItem {
  function namespace (line 126) | namespace rml {

FILE: third-party/tbb/src/tbbmalloc/tbbmalloc.cpp
  type rml (line 32) | namespace rml {
    type internal (line 33) | namespace internal {
      function init_tbbmalloc (line 54) | void init_tbbmalloc() {
      function BOOL (line 77) | BOOL WINAPI DllMain( HINSTANCE /*hInst*/, DWORD callReason, LPVOID l...
      type RegisterProcessShutdownNotification (line 90) | struct RegisterProcessShutdownNotification {
        method RegisterProcessShutdownNotification (line 92) | RegisterProcessShutdownNotification() {
        method RegisterProcessShutdownNotification (line 102) | RegisterProcessShutdownNotification(RegisterProcessShutdownNotific...
        method RegisterProcessShutdownNotification (line 103) | RegisterProcessShutdownNotification& operator=(const RegisterProce...

FILE: third-party/tbb/src/tbbmalloc/tbbmalloc_internal.h
  type pthread_key_t (line 25) | typedef pthread_key_t tls_key_t;
  type DWORD (line 28) | typedef DWORD tls_key_t;
  function namespace (line 87) | namespace rml {
  type LargeObjectHdr (line 644) | struct LargeObjectHdr {
  type FreeObject (line 651) | struct FreeObject {
  function class (line 659) | class RecursiveMallocCallProtector {
  function class (line 744) | class RecursiveMallocCallProtector {

FILE: third-party/tbb/src/tbbmalloc/tbbmalloc_internal_api.h
  type AllocationModeInternalParam (line 24) | typedef enum {

FILE: third-party/tbb/src/tbbmalloc_proxy/function_replacement.cpp
  type FunctionInfo (line 42) | struct FunctionInfo {
  type Log (line 49) | namespace Log {
    function record (line 66) | static void record(FunctionInfo functionInfo, const char * opcodeStrin...
  function UINT_PTR (line 92) | inline UINT_PTR Ptr2Addrint(LPVOID ptr)
  function LPVOID (line 99) | inline LPVOID Addrint2Ptr(UINT_PTR ptr)
  function IsInDistance (line 107) | inline bool IsInDistance(UINT_PTR addr1, UINT_PTR addr2, __int64 dist)
  class MemoryProvider (line 128) | class MemoryProvider {
    type MemoryBuffer (line 130) | struct MemoryBuffer {
      method MemoryBuffer (line 136) | MemoryBuffer() : m_base(0), m_next(0), m_size(0) {}
      method MemoryBuffer (line 139) | MemoryBuffer(void *base, DWORD size)
    method MemoryBuffer (line 147) | MemoryBuffer *CreateBuffer(UINT_PTR addr)
      method MemoryBuffer (line 136) | MemoryBuffer() : m_base(0), m_next(0), m_size(0) {}
      method MemoryBuffer (line 139) | MemoryBuffer(void *base, DWORD size)
    method MemoryProvider (line 190) | MemoryProvider()
    method UINT_PTR (line 206) | UINT_PTR GetLocation(UINT_PTR addr)
  function compareStrings (line 239) | size_t compareStrings( const char *str1, const char *str2 )
  function UINT (line 253) | static UINT CheckOpcodes( const char ** opcodes, void *inpAddr, bool abo...
  function CorrectOffset (line 303) | static void CorrectOffset( UINT_PTR address, const char* pattern, UINT d...
  function DWORD (line 318) | static DWORD InsertTrampoline32(void *inpAddr, void *targetAddr, const c...
  function DWORD (line 373) | static DWORD InsertTrampoline64(void *inpAddr, void *targetAddr, const c...
  function InsertTrampoline (line 435) | static bool InsertTrampoline(void *inpAddr, void *targetAddr, const char...
  function FRR_TYPE (line 478) | FRR_TYPE ReplaceFunctionA(const char *dllName, const char *funcName, FUN...
  function FRR_TYPE (line 518) | FRR_TYPE ReplaceFunctionW(const wchar_t *dllName, const char *funcName, ...
  function IsPrologueKnown (line 558) | bool IsPrologueKnown(const char* dllName, const char *funcName, const ch...
  function TBB_malloc_replacement_log (line 572) | __declspec(dllexport) int TBB_malloc_replacement_log(char *** function_r...

FILE: third-party/tbb/src/tbbmalloc_proxy/function_replacement.h
  type FRR_TYPE (line 21) | typedef enum {
  type FRR_ON_ERROR (line 28) | typedef enum {

FILE: third-party/tbb/src/tbbmalloc_proxy/proxy.cpp
  function initPageSize (line 122) | static inline void initPageSize()
  function InitOrigPointers (line 161) | inline void InitOrigPointers()
  function InitOrigPointers (line 183) | inline void InitOrigPointers() {}
  function TBBMALLOCPROXY_EXPORT (line 187) | TBBMALLOCPROXY_EXPORT void *PREFIX(malloc)(ZONE_ARG size_t size) __THROW
  function TBBMALLOCPROXY_EXPORT (line 192) | TBBMALLOCPROXY_EXPORT void *PREFIX(calloc)(ZONE_ARG size_t num, size_t s...
  function TBBMALLOCPROXY_EXPORT (line 197) | TBBMALLOCPROXY_EXPORT void PREFIX(free)(ZONE_ARG void *object) __THROW
  function TBBMALLOCPROXY_EXPORT (line 203) | TBBMALLOCPROXY_EXPORT void *PREFIX(realloc)(ZONE_ARG void* ptr, size_t s...
  function TBBMALLOCPROXY_EXPORT (line 212) | TBBMALLOCPROXY_EXPORT void *PREFIX(memalign)(ZONE_ARG size_t alignment, ...
  function TBBMALLOCPROXY_EXPORT (line 218) | TBBMALLOCPROXY_EXPORT void *PREFIX(valloc)(ZONE_ARG size_t size) __THROW
  function TBBMALLOCPROXY_EXPORT (line 232) | TBBMALLOCPROXY_EXPORT size_t malloc_usable_size(const void *ptr) __THROW
  function TBBMALLOCPROXY_EXPORT (line 241) | TBBMALLOCPROXY_EXPORT int posix_memalign(void **memptr, size_t alignment...
  function TBBMALLOCPROXY_EXPORT (line 248) | TBBMALLOCPROXY_EXPORT void *pvalloc(size_t size) __THROW
  function TBBMALLOCPROXY_EXPORT (line 258) | TBBMALLOCPROXY_EXPORT int mallopt(int /*param*/, int /*value*/) __THROW
  function TBBMALLOCPROXY_EXPORT (line 264) | TBBMALLOCPROXY_EXPORT struct mallinfo mallinfo() __THROW
  function TBBMALLOCPROXY_EXPORT (line 294) | TBBMALLOCPROXY_EXPORT void __libc_free(void *ptr)
  function TBBMALLOCPROXY_EXPORT (line 300) | TBBMALLOCPROXY_EXPORT void *__libc_realloc(void *ptr, size_t size)
  function TBBMALLOCPROXY_EXPORT (line 311) | TBBMALLOCPROXY_EXPORT void* operator new(size_t sz) {
  function TBBMALLOCPROXY_EXPORT (line 314) | TBBMALLOCPROXY_EXPORT void* operator new[](size_t sz) {
  function TBBMALLOCPROXY_EXPORT (line 317) | TBBMALLOCPROXY_EXPORT void operator delete(void* ptr) noexcept {
  function TBBMALLOCPROXY_EXPORT (line 321) | TBBMALLOCPROXY_EXPORT void operator delete[](void* ptr) noexcept {
  function TBBMALLOCPROXY_EXPORT (line 325) | TBBMALLOCPROXY_EXPORT void* operator new(size_t sz, const std::nothrow_t...
  function TBBMALLOCPROXY_EXPORT (line 328) | TBBMALLOCPROXY_EXPORT void* operator new[](std::size_t sz, const std::no...
  function TBBMALLOCPROXY_EXPORT (line 331) | TBBMALLOCPROXY_EXPORT void operator delete(void* ptr, const std::nothrow...
  function TBBMALLOCPROXY_EXPORT (line 335) | TBBMALLOCPROXY_EXPORT void operator delete[](void* ptr, const std::nothr...
  function arrayLength (line 353) | inline size_t arrayLength(const T(&)[N]) {
  function __TBB_malloc_safer_delete (line 357) | void __TBB_malloc_safer_delete( void *ptr)
  function __TBB_malloc__o_free (line 413) | void __TBB_malloc__o_free(void *ptr)
  function __TBB_malloc__free_base (line 419) | void __TBB_malloc__free_base(void *ptr)
  function operator_delete (line 535) | void operator_delete(void* ptr) noexcept {
  function operator_delete_arr (line 542) | void operator_delete_arr(void* ptr) noexcept {
  function operator_delete_t (line 551) | void operator_delete_t(void* ptr, const std::nothrow_t&) noexcept {
  function operator_delete_arr_t (line 554) | void operator_delete_arr_t(void* ptr, const std::nothrow_t&) noexcept {
  type Module (line 558) | struct Module {
  type FRData_t (line 615) | struct FRData_t {
  function BytecodesAreKnown (line 655) | bool BytecodesAreKnown(const unicode_char_t *dllName)
  function SkipReplacement (line 671) | void SkipReplacement(const unicode_char_t *dllName)
  function ReplaceFunctionWithStore (line 693) | void ReplaceFunctionWithStore( const unicode_char_t *dllName, const char...
  function doMallocReplacement (line 709) | void doMallocReplacement()
  function BOOL (line 771) | BOOL WINAPI DllMain( HINSTANCE hInst, DWORD callReason, LPVOID reserved )
  function __TBB_malloc_proxy (line 791) | __declspec(dllexport) void __TBB_malloc_proxy()

FILE: third-party/tbb/src/tbbmalloc_proxy/proxy.h
  type orig_ptrs (line 45) | struct orig_ptrs {
  type orig_aligned_ptrs (line 50) | struct orig_aligned_ptrs {

FILE: third-party/tbb/src/tbbmalloc_proxy/proxy_overload_osx.h
  function kern_return_t (line 52) | static kern_return_t enumerator(task_t, void *, unsigned, vm_address_t,
  function good_size (line 58) | static size_t good_size(malloc_zone_t *, size_t size)
  function boolean_t (line 63) | static boolean_t zone_check(malloc_zone_t *) /* Consistency checker */
  function zone_print (line 68) | static void zone_print(malloc_zone_t *, boolean_t) { }
  function zone_log (line 69) | static void zone_log(malloc_zone_t *, void *) {}
  function zone_force_lock (line 70) | static void zone_force_lock(malloc_zone_t *) {}
  function zone_force_unlock (line 71) | static void zone_force_unlock(malloc_zone_t *) {}
  function zone_statistics (line 73) | static void zone_statistics(malloc_zone_t *, malloc_statistics_t *s)
  function boolean_t (line 79) | static boolean_t zone_locked(malloc_zone_t *)
  function boolean_t (line 84) | static boolean_t impl_zone_enable_discharge_checking(malloc_zone_t *)
  function impl_zone_disable_discharge_checking (line 89) | static void impl_zone_disable_discharge_checking(malloc_zone_t *) {}
  function impl_zone_discharge (line 90) | static void impl_zone_discharge(malloc_zone_t *, void *) {}
  function impl_zone_destroy (line 91) | static void impl_zone_destroy(struct _malloc_zone_t *) {}
  function impl_malloc_usable_size (line 94) | static size_t impl_malloc_usable_size(struct _malloc_zone_t *, const voi...
  type _malloc_zone_t (line 101) | struct _malloc_zone_t
  type _malloc_zone_t (line 102) | struct _malloc_zone_t
  type _malloc_zone_t (line 103) | struct _malloc_zone_t
  type _malloc_zone_t (line 104) | struct _malloc_zone_t
  type _malloc_zone_t (line 105) | struct _malloc_zone_t
  type _malloc_zone_t (line 106) | struct _malloc_zone_t
  function impl_free_definite_size (line 109) | static void impl_free_definite_size(struct _malloc_zone_t*, void *ptr, s...
  function impl_pressure_relief (line 115) | static size_t impl_pressure_relief(struct _malloc_zone_t *, size_t  /* g...
  type DoMallocReplacement (line 122) | struct DoMallocReplacement {

FILE: third-party/tbb/test/common/allocator_stl_test_common.h
  function MoveOperationTracker (line 67) | struct MoveOperationTracker {
  function operator (line 85) | bool operator==(int value) const {

FILE: third-party/tbb/test/common/allocator_test_common.h
  function PseudoRandomValue (line 74) | inline char PseudoRandomValue( size_t j, size_t k ) {
  function class (line 83) | class DisableStderr {
  type typename (line 156) | typedef typename A::template
  function a (line 227) | a(a_) {}
  function check_allocate (line 228) | void check_allocate(pointer_type array[], std::size_t i, std::size_t t) ...
  function check_deallocate (line 242) | void check_deallocate(pointer_type array[], std::size_t i, std::size_t t...
  function const (line 253) | void operator()(std::size_t thread_id) const {
  type TestName (line 274) | enum TestName { Concept, Broken, Exceptions, ThreadSafety, Comparison }

FILE: third-party/tbb/test/common/checktype.h
  function class (line 25) | class DestroyedTracker {
  function DestroyedTracker (line 64) | CheckType( const CheckType& other ) : DestroyedTracker(other) {
  function Counter (line 92) | Counter id() const {
  function get_ready (line 102) | void get_ready() {
  function namespace (line 115) | namespace std {

FILE: third-party/tbb/test/common/common_arena_constraints.h
  function get_processors_group_count (line 38) | int get_processors_group_count() {
  function get_processors_group_count (line 57) | int get_processors_group_count() { return 1; }
  type index_info (line 98) | struct index_info {
  function concurrency (line 100) | int concurrency{-1};
  function class (line 143) | class system_info {
  function required_info (line 397) | auto required_info = std::find_if(numa_nodes_info.begin(), numa_nodes_in...
  function required_info (line 407) | auto required_info = std::find_if(core_types_info.begin(), core_types_in...
  function test_constraints_affinity_and_concurrency (line 417) | void test_constraints_affinity_and_concurrency(tbb::task_arena::constrai...
  type constraints_equal (line 497) | struct constraints_equal {
  function constraints_container (line 508) | constraints_container generate_constraints_variety() {

FILE: third-party/tbb/test/common/concepts_common.h
  function namespace (line 28) | namespace test_concepts {
  type DefaultInitializable (line 49) | struct DefaultInitializable { DefaultInitializable() = default; }
  type NonDefaultInitializable (line 50) | struct NonDefaultInitializable { NonDefaultInitializable() = delete; }
  function namespace (line 52) | namespace blocked_range_value {
  function namespace (line 99) | namespace range {
  function is_divisible (line 114) | bool is_divisible() requires (EnableIsDivisible == State::incorrect_cons...
  function Dummy (line 115) | Dummy is_divisible() const requires (EnableIsDivisible == State::incorre...
  function namespace (line 151) | namespace parallel_for_function {
  function namespace (line 165) | namespace parallel_for_index {
  function const (line 214) | void operator()( const T& ) const requires (EnableFunctionCallOperator =...
  function const (line 216) | void operator()( Dummy ) const requires (EnableFunctionCallOperator == S...
  function const (line 221) | void operator()( const T&, tbb::feeder<FeederT>& ) const requires (Enabl...
  function T (line 263) | T* begin() requires EnableBegin { return nullptr; }
  function T (line 264) | T* end() requires EnableEnd { return nullptr; }
  type ConstantCBS (line 274) | struct ConstantCBS {
  function namespace (line 285) | namespace parallel_reduce_body {
  function namespace (line 309) | namespace parallel_reduce_function {
  function namespace (line 327) | namespace parallel_reduce_combine {
  function T (line 383) | T operator()( const Range&, const T& a, bool ) const requires (EnableFun...
  function T (line 384) | T operator()( const Range&, const T& a, bool ) requires (EnableFunctionC...
  function T (line 385) | T operator()( Dummy, const T& a, bool ) const requires (EnableFunctionCa...
  function T (line 386) | T operator()( const Range&, Dummy, bool ) const requires (EnableFunction...
  function T (line 387) | T operator()( const Range&, const T& a, Dummy ) const requires (EnableFu...
  function Dummy (line 388) | Dummy operator()( const Range&, const T&, bool ) const requires (EnableF...
  function const (line 406) | bool operator()( const T&, const T& ) const requires (EnableFunctionCall...
  function const (line 407) | bool operator()( Dummy, const T& ) const requires (EnableFunctionCallOpe...
  function const (line 408) | bool operator()( const T&, Dummy ) const requires (EnableFunctionCallOpe...
  function Dummy (line 409) | Dummy operator()( const T&, const T& ) const requires (EnableFunctionCal...
  function Dummy (line 431) | Dummy hash( const Key& ) const requires (EnableHash == State::incorrect_...
  function equal (line 433) | bool equal( const Key&, const Key& ) const requires (EnableEqual == Stat...
  function equal (line 434) | bool equal( const Key&, const Key& ) requires (EnableEqual == State::inc...
  function equal (line 435) | bool equal( Dummy, const Key& ) const requires (EnableEqual == State::in...
  function equal (line 436) | bool equal( const Key&, Dummy ) const requires (EnableEqual == State::in...
  function Dummy (line 437) | Dummy equal( const Key&, const Key& ) const requires (EnableEqual == Sta...
  type scoped_lock (line 458) | struct scoped_lock {
  function try_acquire (line 471) | bool try_acquire( RwMutex&, Dummy = Dummy{} ) requires (EnableSLTryAcqui...
  function Dummy (line 472) | Dummy try_acquire( RwMutex&, bool = true ) requires (EnableSLTryAcquire ...
  function namespace (line 569) | namespace function_node_body {
  function namespace (line 590) | namespace mf_async_node_body {
  function namespace (line 605) | namespace multifunction_node_body {
  function namespace (line 619) | namespace async_node_body {
  function namespace (line 633) | namespace continue_node_body {
  function namespace (line 654) | namespace sequencer {
  function namespace (line 675) | namespace join_node_function_object {

FILE: third-party/tbb/test/common/concurrency_tracker.h
  function namespace (line 27) | namespace utils {

FILE: third-party/tbb/test/common/concurrent_associative_common.h
  function Value (line 59) | static Value make( const Key& key ) { return Value(key, key); }
  function Value (line 60) | static Value make( const Key& key, const Key& mapped ) { return Value(ke...
  function strip_key (line 61) | static strip_key key( const Value& value ) { return value.first; }
  function strip_key (line 62) | static strip_key get( const Value& value ) { return strip_key(value.seco...
  function U (line 64) | U convert( const Value& value ) { return U(value.second); }
  function Test (line 69) | static void Test() {}
  function Key (line 75) | static Key make( const Key& key ) { return key; }
  function Key (line 76) | static Key make( const Key& key, const Key& ) { return key; }
  function Key (line 77) | static Key key( const Key& value ) { return value; }
  function Key (line 78) | static Key get( const Key& value ) { return value; }
  function U (line 80) | U convert( const Key& value ) { return U(value); }
  function compare (line 86) | bool compare( const typename Container::iterator& it, U val ) {
  function check_value_state (line 240) | void check_value_state(const T&, std::false_type) {}
  function namespace (line 257) | namespace emplace_helpers {
  function break_value (line 392) | void break_value( move_support_tests::FooWithAssign& value ) {
  function const (line 682) | void operator()( int thread_index ) const {
  function const (line 770) | void operator()(int i) const {
  function namespace (line 970) | namespace test {
  function namespace (line 984) | namespace std {
  type CallIf (line 1000) | struct CallIf
  function namespace (line 1085) | namespace detail {
  type int_key (line 1231) | struct int_key {
  function const (line 1244) | struct char_key {
  function string (line 1257) | string c) {
  function string (line 1271) | string c ) {
  type equal_to (line 1283) | struct equal_to {
  type hash_with_transparent_key_equal (line 1291) | struct hash_with_transparent_key_equal {
  function hash (line 1299) | size_t hash(const int& key) const { return (first_factor * key + second_...
  function hash (line 1301) | size_t hash(const int_key& key) const { return (first_factor * key.my_it...
  function hash (line 1303) | size_t hash(const std::string& key) const {
  function hash (line 1311) | size_t hash(const char_key& key) const {
  function char_key (line 1409) | char_key k{*it};
  function char_key (line 1417) | char_key k{*it};
  function char_key (line 1447) | char_key k{*it};
  function CountingKey (line 1455) | struct CountingKey {
  function reset (line 1463) | static void reset() { counter = 0; }
  function namespace (line 1468) | namespace std {
  function CountingKey (line 1475) | const CountingKey&, const CountingKey& ) { return true; }
  function CountingKey (line 1477) | const CountingKey&, const CountingKey& ) { return true; }
  type int_constructible_object (line 1479) | struct int_constructible_object {
  function int_constructible_object (line 1484) | int_constructible_object rhs ) {
  function counting_generic_pair (line 1522) | counting_generic_pair counting_pair(CountingKey{}
  function Container (line 1535) | Container c1{}
  function Container (line 1536) | Container c2{Value<Container>::make(1), Value<Container>::make(2)};

FILE: third-party/tbb/test/common/concurrent_lru_cache_common.h
  function namespace (line 29) | namespace concurrent_lru_cache_helpers {
  function namespace (line 140) | namespace concurrent_lru_cache_presets {
  type preset_instance_count (line 205) | struct preset_instance_count
  type preset_map_instance_count (line 224) | struct preset_map_instance_count
  function is_evicted (line 238) | bool is_evicted(std::size_t key) {
  function fill_up_cache (line 248) | void fill_up_cache(std::size_t lower_bound, std::size_t upper_bound) {

FILE: third-party/tbb/test/common/concurrent_ordered_common.h
  type OrderedMoveTraitsBase (line 162) | struct OrderedMoveTraitsBase {
  function equal (line 184) | bool equal( const OrderedType& c, Iterator begin, Iterator end ) {
  function namespace (line 194) | namespace std {
  type TransparentLess (line 278) | struct TransparentLess {

FILE: third-party/tbb/test/common/concurrent_priority_queue_common.h
  function namespace (line 28) | namespace equality_comparison_helpers {
  type LessForSmartPointers (line 188) | struct LessForSmartPointers {
  function const (line 304) | void operator()( const std::size_t thread_id ) const {

FILE: third-party/tbb/test/common/concurrent_unordered_common.h
  function const (line 43) | size_t operator()(const T& /*a*/) const {
  type UnorderedMoveTraitsBase (line 116) | struct UnorderedMoveTraitsBase {
  function equal (line 138) | bool equal( const UnorderedType& c, Iterator begin, Iterator end ) {
  function Table (line 232) | Table c2_hash_alloc({*it++, *it++, *it++}, initial_bucket_number, hasher...
  type hasher_with_transparent_key_equal (line 305) | struct hasher_with_transparent_key_equal {

FILE: third-party/tbb/test/common/container_move_support.h
  function namespace (line 29) | namespace move_support_tests {
  function verify_no_undestroyed_foo_left_and_dismiss (line 80) | void verify_no_undestroyed_foo_left_and_dismiss() {
  function save_allocator_counters (line 98) | void save_allocator_counters(){ previous_state = static_counter_allocato...
  function verify_no_more_than_x_memory_items_allocated (line 99) | void verify_no_more_than_x_memory_items_allocated(std::size_t  expected_...
  function bad_alloc (line 105) | struct FooException : std::bad_alloc {
  type FooLimit (line 111) | struct FooLimit {
  function zero_bar (line 132) | intptr_t& zero_bar() {
  function zero_bar (line 137) | intptr_t zero_bar() const {
  function bar (line 147) | intptr_t bar() const {
  function set_thread_id (line 160) | void set_thread_id( std::size_t t ) {
  function state_trackable_type (line 170) | Foo( intptr_t br ) : state_trackable_type(0) {
  function state_trackable_type (line 180) | Foo( const Foo& foo ) : state_trackable_type(foo) {
  function is_const (line 245) | bool is_const() { return false; }
  function Foo (line 251) | struct FooWithAssign : Foo {
  function class (line 295) | class FooIterator : public FooIteratorBase<FooIterator> {
  function class (line 311) | class FooPairIterator : public FooIteratorBase<FooPairIterator> {
  type MemoryLocations (line 329) | struct MemoryLocations {
  function verify_allocator_was_moved (line 411) | void verify_allocator_was_moved( const allocator_type& result_allocator ) {
  function init (line 459) | void init() {
  function content_location_unchanged (line 465) | bool content_location_unchanged( const container_type& dst ) {
  function content_location_changed (line 469) | bool content_location_changed( const container_type& dst ) {
  function verify_content_equal_to_source (line 478) | void verify_content_equal_to_source( const container_type& dst ) {
  function verify_content_equal_to_source (line 482) | void verify_content_equal_to_source( const container_type& dst, std::siz...
  function verify_content_shallow_moved (line 487) | void verify_content_shallow_moved( const container_type& dst ) {
  function verify_content_deep_moved (line 494) | void verify_content_deep_moved( const container_type& dst ) {
  function verify_part_of_content_deep_moved (line 504) | void verify_part_of_content_deep_moved(container_type const& dst, std::s...
  function save_allocator_counters (line 540) | void save_allocator_counters() { previous_state = StaticCountingAllocato...
  function verify_no_more_than_x_memory_items_allocated (line 542) | void verify_no_more_than_x_memory_items_allocated( std::size_t expected ) {
  function verify_no_undestroyed_foo_left_and_dismiss (line 549) | struct TrackFooCount {
  type DefaultStatefulFixture (line 579) | struct DefaultStatefulFixture
  function verify_no_more_than_x_memory_items_allocated (line 596) | void verify_no_more_than_x_memory_items_allocated() {
  type LimitFooCountInScope (line 629) | struct LimitFooCountInScope {
  function namespace (line 843) | namespace std {
  function FooWithAssign (line 852) | struct hash<move_support_tests::FooWithAssign> {

FILE: third-party/tbb/test/common/containers_common.h
  type NonMovableObject (line 58) | struct NonMovableObject {
  function namespace (line 66) | namespace std {
  type ThrowOnCopy (line 133) | struct ThrowOnCopy {
  function activate (line 142) | static void activate() { is_active = true; }
  function deactivate (line 143) | static void deactivate() { is_active = false; }
  function namespace (line 153) | namespace std {
  type hash (line 171) | struct hash

FILE: third-party/tbb/test/common/cpu_usertime.h
  function GetCPUUserTime (line 38) | inline double GetCPUUserTime() {

FILE: third-party/tbb/test/common/custom_allocators.h
  type ArenaAllocator (line 44) | struct ArenaAllocator {
  function value_type (line 70) | const value_type* address( const value_type& x ) const { return &x; }
  function deallocate (line 79) | void deallocate( value_type* ptr, std::size_t n ) {
  function set_counters (line 119) | void set_counters( std::size_t it_allocated, std::size_t it_freed,
  function clear_counters (line 136) | void clear_counters() {
  function deallocate (line 171) | void deallocate( value_type* ptr, std::size_t n ) {
  function set_limits (line 189) | void set_limits( std::size_t max ) {
  type AllocatorCounters (line 194) | struct AllocatorCounters {
  function base_type (line 267) | base_type(other) {}
  function deallocate (line 282) | void deallocate(const pointer ptr, const std::size_t n){
  function AllocatorCounters (line 300) | static AllocatorCounters counters() {
  function init_counters (line 304) | static void init_counters() {
  function init_counters (line 336) | struct StaticSharedCountingAllocatorBase {
  function alloc_base_type (line 398) | alloc_base_type(other) {}
  function deallocate (line 418) | void deallocate( value_type* ptr, std::size_t n ) {
  function activate (line 474) | static void activate() { assert_on_constructions = true; }
  function deactivate (line 475) | static void deactivate() { assert_on_constructions = false; }
  function namespace (line 494) | namespace std {
  function base_allocator (line 610) | base_allocator(other) {}
  function base_allocator (line 632) | base_allocator(other) {}

FILE: third-party/tbb/test/common/doctest.h
  function namespace (line 459) | namespace doctest { namespace detail {
  function namespace (line 535) | namespace std { // NOLINT(cert-dcl58-cpp)
  function namespace (line 571) | namespace doctest {
  function String (line 1089) | String convert(const DOCTEST_REF_WRAP(T)) {
  type StringMakerBase (line 1120) | struct StringMakerBase
  function String (line 1122) | String convert(const DOCTEST_REF_WRAP(T) in) {
  function namespace (line 1196) | namespace detail {
  function DOCTEST_MSVC_SUPPRESS_WARNING_POP (line 1223) | DOCTEST_MSVC_SUPPRESS_WARNING_POP
  function void (line 1236) | struct filldata<const void*> {
  function fill (line 1243) | void fill(std::ostream* stream, const T* in) {
  function public (line 2626) | public base                                                             ...
  function resetRunData (line 3587) | void resetRunData() {
  function finalizeTestCaseData (line 3598) | void finalizeTestCaseData() {

FILE: third-party/tbb/test/common/dummy_body.h
  function namespace (line 23) | namespace utils {

FILE: third-party/tbb/test/common/exception_handling.h
  function class (line 63) | class eh_test_observer : public tbb::task_scheduler_observer {
  function class (line 100) | class test_exception : public std::exception {
  function class (line 108) | class solitary_test_exception : public test_exception {
  function ThrowTestException (line 120) | inline void ThrowTestException () {
  function ThrowTestException (line 129) | inline void ThrowTestException ( intptr_t threshold ) {
  function ThrowTestException (line 209) | inline void ThrowTestException ( intptr_t ) {}
  function WaitUntilConcurrencyPeaks (line 232) | void WaitUntilConcurrencyPeaks ( int expected_peak ) {
  function WaitUntilConcurrencyPeaks (line 256) | inline void WaitUntilConcurrencyPeaks () { WaitUntilConcurrencyPeaks(g_N...
  function IsMaster (line 258) | inline bool IsMaster() {
  function IsThrowingThread (line 262) | inline bool IsThrowingThread() {
  function m_cancellationThreshold (line 266) | struct Cancellator {
  function Reset (line 286) | static void Reset () { s_Ready = false; }
  function WaitUntilReady (line 288) | static bool WaitUntilReady () {

FILE: third-party/tbb/test/common/fp_control.h
  function SetRoundingMode (line 60) | inline void SetRoundingMode ( int mode ) {
  function GetSseMode (line 75) | inline int GetSseMode () {
  function SetSseMode (line 81) | inline void SetSseMode ( int mode ) {
  function GetSseMode (line 92) | inline int GetSseMode () { return 0; }
  function SetSseMode (line 93) | inline void SetSseMode ( int ) {}
  function SetRoundingMode (line 105) | inline void SetRoundingMode ( int mode ) {
  function SetRoundingMode (line 121) | inline void SetRoundingMode ( int rnd ) { fesetround(rnd); }
  function GetSseMode (line 123) | inline int GetSseMode () { return 0; }
  function SetSseMode (line 124) | inline void SetSseMode ( int ) {}
  function SetFPMode (line 132) | inline void SetFPMode( int mode ) {
  function class (line 148) | class FPModeContext {
  function setNextFPMode (line 162) | int setNextFPMode() {
  function assertFPMode (line 166) | void assertFPMode() {

FILE: third-party/tbb/test/common/graph_utils.h
  function OutputType (line 45) | static OutputType convert_value(const InputType &i) {
  function tbb (line 52) | static tbb::flow::continue_msg convert_value(const InputType &/*i*/) {
  function OutputType (line 59) | static OutputType convert_value(const tbb::flow::continue_msg &/*i*/) {
  function output_converted_value (line 68) | inline void output_converted_value(const InputType &i, ports_type &p) {
  type mof_helper (line 75) | struct mof_helper
  function output_converted_value (line 77) | inline void output_converted_value(const InputType &i, ports_type &p) {
  function OutputType (line 85) | static OutputType construct( InputType v ) {
  function OutputType (line 92) | static OutputType construct( tbb::flow::continue_msg ) {
  function tbb (line 99) | static tbb::flow::continue_msg construct( InputType ) {
  type harness_graph_default_functor (line 105) | struct harness_graph_default_functor
  function tbb (line 106) | static tbb::flow::continue_msg construct( tbb::flow::continue_msg ) {
  type typename (line 114) | typedef typename tbb::flow::multifunction_node<InputType,OutputSet>::out...
  function construct (line 115) | static void construct(const InputType &i, ports_type &p) {
  type OutputType (line 124) | typedef OutputType (*function_ptr_type)( InputType v );
  function OutputType (line 134) | static inline OutputType func( InputType v ) {
  function OutputType (line 147) | inline OutputType tfunc( InputType v ) {
  function OutputType (line 159) | OutputType operator()( InputType i ) {
  type tfunctor (line 165) | typedef tfunctor<tbb::null_rw_mutex> functor;
  type typename (line 172) | typedef typename tbb::flow::multifunction_node<InputType,OutputTuple>::o...
  function empty_func (line 185) | static inline void empty_func( const InputType&, ports_type& ) {
  function func (line 188) | static inline void func( const InputType &v, ports_type &p ) {
  function tfunc (line 199) | inline void tfunc( const InputType& v, ports_type &p ) {
  type tfunctor (line 216) | typedef tfunctor<tbb::null_rw_mutex> functor;
  function initialize_map (line 270) | void initialize_map( const T& m, size_t c ) {
  function override (line 276) | const override {
  function validate (line 291) | void validate() {
  type tbb (line 306) | typedef tbb::concurrent_unordered_multiset<T> multiset_type;
  function initialize_map (line 324) | void initialize_map( const T& m, size_t c ) {
  function override (line 347) | const override {
  function validate (line 351) | void validate() {
  function reset_receiver (line 365) | void reset_receiver(tbb::flow::reset_flags /*f*/) {
  type typename (line 379) | typedef typename tbb::flow::sender<T>::successor_type successor_type;
  function my_limit (line 391) | harness_counting_sender( size_t limit ) : my_limit(limit) {
  function register_successor (line 397) | bool register_successor( successor_type &r ) override {
  function remove_successor (line 402) | bool remove_successor( successor_type &r ) override {
  function try_get (line 408) | bool try_get( T & v ) override {
  function try_get (line 420) | bool try_get( T & v, tbb::detail::d2::message_metainfo& ) override {
  function try_put_once (line 425) | bool try_put_once() {
  function try_put_until_false (line 436) | void try_put_until_false() {
  function try_put_until_limit (line 446) | void try_put_until_limit() {
  type std (line 462) | typedef std::vector< std::shared_ptr<harness_counting_sender<InputType>>...
  function my_senders (line 466) | my_senders(senders) {}
  function const (line 468) | void operator()( int i ) const  { my_senders[i]->try_put_until_limit(); }
  function T (line 480) | T operator()(const T& in) {
  function T (line 495) | T operator()(const tbb::flow::continue_msg& /*in*/) {
  function T (line 515) | T j{}
  function const (line 650) | void operator()(DataType i) const {
  function namespace (line 699) | namespace lightweight_testing {
  function const (line 762) | void operator()(int) const noexcept {
  type condition_predicate (line 773) | struct condition_predicate {
  function output_tuple_type (line 810) | output_tuple_type operator()(const std::thread::id& input) noexcept(NoEx...
  type NodeType (line 922) | typedef NodeType<input_type, output_tuple_type, tbb::flow::queueing_ligh...

FILE: third-party/tbb/test/common/initializer_list_support.h
  function namespace (line 26) | namespace initializer_list_support_tests {

FILE: third-party/tbb/test/common/iterator.h
  type std (line 31) | typedef std::allocator<T> allocator_type;
  type std (line 32) | typedef std::allocator_traits<allocator_type> allocator_traits_type;
  type T (line 35) | typedef T value_type;
  type typename (line 36) | typedef typename allocator_traits_type::difference_type difference_type;
  type typename (line 37) | typedef typename allocator_traits_type::pointer pointer;
  type typename (line 38) | typedef typename allocator_traits_type::value_type& reference;
  function my_ptr (line 40) | my_ptr(nullptr) {}
  type Epoch (line 97) | struct Epoch {
  type std (line 112) | typedef std::allocator<T> allocator_type;
  type std (line 113) | typedef std::allocator_traits<allocator_type> allocator_traits_type;
  type T (line 116) | typedef T value_type;
  type typename (line 117) | typedef typename allocator_traits_type::difference_type difference_type;
  type typename (line 118) | typedef typename allocator_traits_type::pointer pointer;
  type typename (line 119) | typedef typename allocator_traits_type::value_type& reference;
  function my_ptr (line 121) | my_ptr(nullptr) {}
  function explicit (line 122) | explicit ForwardIterator ( T * ptr ) : my_ptr(ptr){}
  function my_ptr (line 124) | ForwardIterator ( const ForwardIterator& r ) : my_ptr(r.my_ptr){}
  type std (line 139) | typedef std::allocator<T> allocator_type;
  type std (line 140) | typedef std::allocator_traits<allocator_type> allocator_traits_type;
  type T (line 143) | typedef T value_type;
  type typename (line 144) | typedef typename allocator_traits_type::pointer pointer;
  type typename (line 145) | typedef typename allocator_traits_type::value_type& reference;
  type typename (line 146) | typedef typename allocator_traits_type::difference_type difference_type;
  function my_ptr (line 148) | my_ptr(nullptr) {}
  function explicit (line 149) | explicit RandomIterator ( T * ptr ) : my_ptr(ptr){}
  function my_ptr (line 150) | RandomIterator ( const RandomIterator& r ) : my_ptr(r.my_ptr){}
  type std (line 197) | typedef std::allocator<T> allocator_type;
  type std (line 198) | typedef std::allocator_traits<allocator_type> allocator_traits_type;
  type T (line 201) | typedef const T value_type;
  type typename (line 202) | typedef typename allocator_traits_type::const_pointer pointer;
  type typename (line 203) | typedef const typename allocator_traits_type::value_type& reference;
  type typename (line 204) | typedef typename allocator_traits_type::difference_type difference_type;
  function my_ptr (line 206) | my_ptr(nullptr) {}
  function explicit (line 207) | explicit ConstRandomIterator ( const T * ptr ) : my_ptr(ptr){}
  function my_ptr (line 208) | ConstRandomIterator ( const ConstRandomIterator& r ) : my_ptr(r.my_ptr){}

FILE: third-party/tbb/test/common/memory_usage.h
  function namespace (line 62) | namespace utils {
  function isTHPEnabledOnMachine (line 143) | inline bool isTHPEnabledOnMachine() {
  function getSystemTHPAllocatedSize (line 159) | inline long long getSystemTHPAllocatedSize() {
  function getSystemTHPCount (line 166) | inline long long getSystemTHPCount() {

FILE: third-party/tbb/test/common/node_handling_support.h
  function namespace (line 29) | namespace node_handling_tests {
  function typename (line 275) | typename Container::value_type& new_value ) {

FILE: third-party/tbb/test/common/parallel_for_each_common.h
  function class (line 39) | class value_t : public utils::NoAfterlife {
  function FindNumOfTasks (line 53) | size_t FindNumOfTasks(size_t max_depth) {
  type FakeTaskGeneratorBody (line 60) | struct FakeTaskGeneratorBody {
  type FakeTaskGeneratorBody_RefVersion (line 69) | struct FakeTaskGeneratorBody_RefVersion {
  type FakeTaskGeneratorBody_ConstRefVersion (line 76) | struct FakeTaskGeneratorBody_ConstRefVersion {
  type FakeTaskGeneratorBody_VolatileRefVersion (line 83) | struct FakeTaskGeneratorBody_VolatileRefVersion {
  type FakeTaskGeneratorBody_RvalueRefVersion (line 90) | struct FakeTaskGeneratorBody_RvalueRefVersion {
  function do_work (line 96) | void do_work(const value_t& depth, tbb::feeder<value_t>& feeder) {
  function TaskGeneratorBody (line 107) | struct TaskGeneratorBody {
  type TaskGeneratorBody_RefVersion (line 123) | struct TaskGeneratorBody_RefVersion {
  type TaskGeneratorBody_ConstVersion (line 130) | struct TaskGeneratorBody_ConstVersion {
  type TaskGeneratorBody_ConstRefVersion (line 137) | struct TaskGeneratorBody_ConstRefVersion {
  type TaskGeneratorBody_VolatileRefVersion (line 144) | struct TaskGeneratorBody_VolatileRefVersion {
  type TaskGeneratorBody_ConstVolatileRefVersion (line 151) | struct TaskGeneratorBody_ConstVolatileRefVersion {
  type TaskGeneratorBody_RvalueRefVersion (line 158) | struct TaskGeneratorBody_RvalueRefVersion {
  type typename (line 168) | typedef typename std::iterator_traits<Iterator>::value_type value_type;
  type std (line 171) | typedef std::move_iterator<Iterator> MoveIterator;
  type typename (line 181) | typedef typename std::iterator_traits<Iterator>::value_type value_type;
  type typename (line 215) | typedef typename std::iterator_traits<Iterator>::value_type value_type;
  type typename (line 227) | typedef typename std::iterator_traits<Iterator>::value_type value_type;
  type std (line 230) | typedef std::move_iterator<Iterator> MoveIterator;
  function validation (line 306) | void validation(std::size_t expected_value) {
  type incremental_functor (line 315) | struct incremental_functor {
  type incremental_functor_const (line 319) | struct incremental_functor_const {
  function namespace (line 330) | namespace TestMoveSem {
  function MovePreferable (line 345) | struct MoveOnly : MovePreferable {
  function const (line 369) | void operator() (T&& in, tbb::feeder<T>& feeder) const { RecordAndAdd(in...
  function const (line 375) | void operator() (T in, tbb::feeder<T>& feeder) const { RecordAndAdd(in, ...
  type typename (line 380) | typedef typename std::iterator_traits<Iterator>::value_type value_type;

FILE: third-party/tbb/test/common/parallel_invoke_common.h
  type generator (line 44) | struct generator {
  type invoke_tree (line 56) | struct invoke_tree {
  function create_level (line 77) | void create_level(/*is_final_level*/std::false_type) const {
  function create_level (line 81) | void create_level(/*is_final_level*/std::true_type) const {
  function generate_and_run (line 90) | static void generate_and_run() {
  function invoke_tuple_args (line 99) | void invoke_tuple_args(tbb::task_group_context* context_ptr, const std::...

FILE: third-party/tbb/test/common/parallel_reduce_common.h
  type utils_default_partitioner (line 30) | struct utils_default_partitioner {}

FILE: third-party/tbb/test/common/range_based_for_support.h
  function namespace (line 24) | namespace range_based_for_support_tests {
  function InitValueType (line 37) | InitValueType range_based_for_accumulate( const Container& c, BinaryAccu...
  type UnifiedSummer (line 46) | struct UnifiedSummer {
  type pair_second_summer (line 58) | struct pair_second_summer{

FILE: third-party/tbb/test/common/rwm_upgrade_downgrade.h
  function mutex_protecting_count (line 32) | mutex_protecting_count(m) {}
  function const (line 34) | void operator()( std::size_t ) const {

FILE: third-party/tbb/test/common/spin_barrier.h
  function namespace (line 35) | namespace utils {
  function U (line 66) | U value) {
  function U (line 73) | U value) {
  function class (line 77) | class WaitWhileEq {
  function class (line 88) | class SpinBarrier {
  function wait (line 162) | bool wait() {
  function signalNoWait (line 167) | bool signalNoWait() {

FILE: third-party/tbb/test/common/state_trackable.h
  function State (line 26) | struct StateTrackableBase {
  function initialize (line 69) | struct StateTrackableCounters {
  function assign_new_state (line 90) | void StateTrackableBase::State::assign_new_state( StateValue s ) noexcept {
  function state (line 112) | StateTrackable( intptr_t ) noexcept : state(DirectInitialized) {}
  function state (line 115) | StateTrackable( const StateTrackable& src ) noexcept : state(CopyInitial...

FILE: third-party/tbb/test/common/test_comparisons.h
  function namespace (line 30) | namespace comparisons_testing {
  function check_two_way_comparison (line 154) | void check_two_way_comparison() {
  function check_equality_comparison (line 172) | void check_equality_comparison() {
  function class (line 181) | class ThreeWayComparable : public TwoWayComparable {
  function reset (line 187) | static void reset() {
  function check_three_way_comparison (line 206) | void check_three_way_comparison() {
  function class (line 216) | class ThreeWayComparableOnly {
  function class (line 232) | class LessComparableOnly {
  function namespace (line 250) | namespace std {

FILE: third-party/tbb/test/common/test_follows_and_precedes_api.h
  function namespace (line 28) | namespace follows_and_precedes_testing{
  function check_impl (line 75) | static void check_impl(tbb::flow::graph& g,
  function check_impl (line 92) | static void check_impl(tbb::flow::graph& g,
  function check_impl (line 107) | static void check_impl(tbb::flow::graph& g,

FILE: third-party/tbb/test/common/test_invoke.h
  function namespace (line 25) | namespace test_invoke {
  function class (line 113) | class SmartValue {

FILE: third-party/tbb/test/common/test_join_node_multiple_predecessors.h
  function namespace (line 23) | namespace multiple_predecessors {

FILE: third-party/tbb/test/common/tls_limit.h
  function class (line 22) | class LimitTLSKeysTo {

FILE: third-party/tbb/test/common/utils.h
  function namespace (line 45) | namespace utils {
  function explicit (line 146) | explicit FastRandom( uint64_t seed )
  function result_type (line 150) | static constexpr result_type max() {
  function result_type (line 154) | static constexpr result_type min() {
  function result_type (line 158) | result_type get( uint64_t seed ) {
  function result_type (line 165) | result_type get( ) { return get(my_seed); }
  function result_type (line 167) | result_type operator() () {
  function class (line 304) | class NoAssign {
  function class (line 312) | class NoCopy : NoAssign {
  function class (line 319) | class Movable {
  function Sleep (line 353) | void Sleep ( int ms ) {
  function array_length (line 370) | inline std::size_t array_length(const T(&)[N]) {
  function compare (line 375) | struct IsEqual {
  function compare (line 388) | bool compare( const std::pair< const std::weak_ptr<T1>, std::weak_ptr<T2...
  function compare (line 395) | bool compare( const T1 &t1, const T2 &t2 ) {
  function class (line 441) | class LifeTrackableObject {

FILE: third-party/tbb/test/common/utils_assert.h
  function namespace (line 27) | namespace utils {

FILE: third-party/tbb/test/common/utils_concurrency_limit.h
  function namespace (line 48) | namespace utils {

FILE: third-party/tbb/test/common/utils_dynamic_libs.h
  function namespace (line 31) | namespace utils {

FILE: third-party/tbb/test/common/utils_env.h
  function namespace (line 24) | namespace utils {

FILE: third-party/tbb/test/common/utils_report.h
  function namespace (line 73) | namespace utils {
  function print_call_stack (line 144) | inline void print_call_stack() {

FILE: third-party/tbb/test/common/utils_yield.h
  function namespace (line 23) | namespace utils {

FILE: third-party/tbb/test/common/vector_types.h
  function have_AVX (line 109) | bool have_AVX() {

FILE: third-party/tbb/test/conformance/conformance_blocked_nd_range.cpp
  class AbstractValueType (line 33) | class AbstractValueType {
    method AbstractValueType (line 35) | AbstractValueType() {}
  function GetValueOf (line 41) | int GetValueOf(const AbstractValueType& v) { return v.value; }
  function AbstractValueType (line 43) | AbstractValueType MakeAbstractValue(int i) {
    method AbstractValueType (line 35) | AbstractValueType() {}
  function AbstractValueType (line 58) | AbstractValueType operator+(const AbstractValueType& u, std::size_t offs...
    method AbstractValueType (line 35) | AbstractValueType() {}
  type range_utils (line 63) | struct range_utils {
    method init_data (line 70) | static void init_data(data_type<EntityType, DimSize>& data) {
    method increment_data (line 75) | static void increment_data(const range_t& range, data_type<EntityType,...
    method check_data (line 85) | static void check_data(const range_t& range, data_type<EntityType, Dim...
    method range_t (line 101) | static range_t make_range(std::size_t shift, bool negative, val_t(*gen...
    method is_empty (line 108) | static bool is_empty(const range_t& range) {
    method is_divisible (line 113) | static bool is_divisible(const range_t& range) {
    method check_splitting (line 118) | static void check_splitting(const range_t& range_split, const range_t&...
  type range_utils<range_t, 0> (line 132) | struct range_utils<range_t, 0> {
    method init_data (line 139) | static void init_data(data_type<EntityType, DimSize>& data) { data = 0; }
    method increment_data (line 142) | static void increment_data(const range_t&, data_type<EntityType, DimSi...
    method check_data (line 145) | static void check_data(const range_t&, data_type<EntityType, DimSize>&...
    method is_empty (line 149) | static bool is_empty(const range_t&) { return false; }
    method is_divisible (line 151) | static bool is_divisible(const range_t&) { return false; }
    method check_splitting (line 153) | static void check_splitting(const range_t&, const range_t&, int(*)(con...
  function MakeInt (line 158) | int MakeInt(int i) { return i; }
  function SerialTest (line 161) | void SerialTest() {
  function ParallelTest (line 191) | void ParallelTest() {

FILE: third-party/tbb/test/conformance/conformance_blocked_range.cpp
  class AbstractValueType (line 31) | class AbstractValueType {
    method AbstractValueType (line 32) | AbstractValueType() {}
    method GetValueOf (line 36) | int GetValueOf( const AbstractValueType& v ) {return v.value;}
  function AbstractValueType (line 39) | AbstractValueType MakeAbstractValueType( int i ) {
    method AbstractValueType (line 32) | AbstractValueType() {}
    method GetValueOf (line 36) | int GetValueOf( const AbstractValueType& v ) {return v.value;}
  function AbstractValueType (line 53) | AbstractValueType operator+( const AbstractValueType& u, std::size_t off...
    method AbstractValueType (line 32) | AbstractValueType() {}
    method GetValueOf (line 36) | int GetValueOf( const AbstractValueType& v ) {return v.value;}
  function SerialTest (line 57) | static void SerialTest() {
  type Striker (line 93) | struct Striker {
  function ParallelTest (line 100) | void ParallelTest() {

FILE: third-party/tbb/test/conformance/conformance_blocked_range2d.cpp
  class AbstractValueType (line 30) | class AbstractValueType {
    method AbstractValueType (line 31) | AbstractValueType() {}
  function MakeAbstractValueType (line 42) | AbstractValueType<Tag> MakeAbstractValueType( int i ) {
  function GetValueOf (line 49) | int GetValueOf( const AbstractValueType<Tag>& v ) {return v.value;}
  type RowTag (line 66) | struct RowTag {}
  type ColTag (line 67) | struct ColTag {}
  function SerialTest (line 69) | static void SerialTest() {
  type Striker (line 114) | struct Striker {
  function ParallelTest (line 123) | void ParallelTest() {

FILE: third-party/tbb/test/conformance/conformance_blocked_range3d.cpp
  class AbstractValueType (line 32) | class AbstractValueType {
    method AbstractValueType (line 33) | AbstractValueType() {}
  function MakeAbstractValueType (line 44) | AbstractValueType<Tag> MakeAbstractValueType( int i ) {
  function GetValueOf (line 51) | int GetValueOf( const AbstractValueType<Tag>& v ) {return v.value;}
  type PageTag (line 68) | struct PageTag {}
  type RowTag (line 69) | struct RowTag {}
  type ColTag (line 70) | struct ColTag {}
  function SerialTest (line 72) | static void SerialTest() {
  type Striker (line 142) | struct Striker {
  function ParallelTest (line 152) | void ParallelTest() {

FILE: third-party/tbb/test/conformance/conformance_blocked_rangeNd.cpp
  class AbstractValueType (line 34) | class AbstractValueType {
    method AbstractValueType (line 36) | AbstractValueType() {}
  function GetValueOf (line 42) | int GetValueOf(const AbstractValueType& v) { return v.value; }
  function AbstractValueType (line 44) | AbstractValueType MakeAbstractValue(int i) {
    method AbstractValueType (line 36) | AbstractValueType() {}
  function AbstractValueType (line 59) | AbstractValueType operator+(const AbstractValueType& u, std::size_t offs...
    method AbstractValueType (line 36) | AbstractValueType() {}
  type range_utils (line 64) | struct range_utils {
    method init_data (line 71) | static void init_data(data_type<EntityType, DimSize>& data) {
    method increment_data (line 76) | static void increment_data(const range_t& range, data_type<EntityType,...
    method check_data (line 86) | static void check_data(const range_t& range, data_type<EntityType, Dim...
    method range_t (line 102) | static range_t make_range(std::size_t shift, bool negative, val_t(*gen...
    method is_empty (line 109) | static bool is_empty(const range_t& range) {
    method is_divisible (line 114) | static bool is_divisible(const range_t& range) {
    method check_splitting (line 119) | static void check_splitting(const range_t& range_split, const range_t&...
  type range_utils<range_t, 0> (line 133) | struct range_utils<range_t, 0> {
    method init_data (line 140) | static void init_data(data_type<EntityType, DimSize>& data) { data = 0; }
    method increment_data (line 143) | static void increment_data(const range_t&, data_type<EntityType, DimSi...
    method check_data (line 146) | static void check_data(const range_t&, data_type<EntityType, DimSize>&...
    method is_empty (line 150) | static bool is_empty(const range_t&) { return false; }
    method is_divisible (line 152) | static bool is_divisible(const range_t&) { return false; }
    method check_splitting (line 154) | static void check_splitting(const range_t&, const range_t&, int(*)(con...
  function MakeInt (line 159) | int MakeInt(int i) { return i; }
  function SerialTest (line 162) | void SerialTest() {
  function ParallelTest (line 192) | void ParallelTest() {

FILE: third-party/tbb/test/conformance/conformance_combinable.cpp
  class minimalCombinable (line 58) | class minimalCombinable {
    method minimalCombinable (line 62) | minimalCombinable(int val=0) : my_value(val) { ++construction_counter; }
    method minimalCombinable (line 63) | minimalCombinable( const minimalCombinable&m ) : my_value(m.my_value) ...
    method minimalCombinable (line 64) | minimalCombinable& operator=(const minimalCombinable& other) { my_valu...
    method minimalCombinable (line 65) | minimalCombinable& operator+=(const minimalCombinable& other) { my_val...
    method set_value (line 68) | void set_value( const int i ) { my_value = i; }
    method value (line 69) | int value( ) const { return my_value; }
  type FunctorAddFinit (line 75) | struct FunctorAddFinit {
    method T (line 76) | T operator()() { return 0; }
  type FunctorAddFinit7 (line 80) | struct FunctorAddFinit7 {
    method T (line 81) | T operator()() { return 7; }
  type FunctorAddCombine (line 85) | struct FunctorAddCombine {
    method T (line 86) | T operator()(T left, T right ) const {
  type FunctorAddCombineRef (line 92) | struct FunctorAddCombineRef {
    method T (line 93) | T operator()(const T& left, const T& right ) const {
  function T (line 99) | T my_combine( T left, T right) { return left + right; }
  function T (line 102) | T my_combine_ref( const T &left, const T &right) { return left + right; }
  class CombineEachHelper (line 105) | class CombineEachHelper {
    method CombineEachHelper (line 107) | CombineEachHelper(T& _result) : my_result(_result) {}
  class CombineEachHelperCnt (line 114) | class CombineEachHelperCnt {
    method CombineEachHelperCnt (line 116) | CombineEachHelperCnt(T& _result, int& _nbuckets) : my_result(_result),...
  class CombineEachVectorHelper (line 124) | class CombineEachVectorHelper {
    method CombineEachVectorHelper (line 127) | CombineEachVectorHelper(T& _result) : my_result(_result) { }
  class ParallelScalarBody (line 142) | class ParallelScalarBody: utils::NoAssign {
    method ParallelScalarBody (line 148) | ParallelScalarBody ( oneapi::tbb::combinable<T> &_sums ) : sums(_sums)...
  class ParallelScalarBodyNoInit (line 163) | class ParallelScalarBodyNoInit: utils::NoAssign {
    method ParallelScalarBodyNoInit (line 169) | ParallelScalarBodyNoInit ( oneapi::tbb::combinable<T> &_sums ) : sums(...
  function RunParallelScalarTests (line 180) | void RunParallelScalarTests(const char* /* test_name */) {
  class ParallelVectorForBody (line 255) | class ParallelVectorForBody: utils::NoAssign {
    method ParallelVectorForBody (line 261) | ParallelVectorForBody ( oneapi::tbb::combinable< std::vector<T, oneapi...
  function RunParallelVectorTests (line 274) | void RunParallelVectorTests(const char* /* test_name */) {
  function RunParallelTests (line 338) | void
  function RunAssignmentAndCopyConstructorTest (line 349) | void
  function RunAssignmentAndCopyConstructorTests (line 381) | void RunAssignmentAndCopyConstructorTests() {
  function RunMoveSemanticsForStateTrackableObjectTest (line 388) | void RunMoveSemanticsForStateTrackableObjectTest() {
  type Body (line 427) | struct Body : utils::NoAssign {
    method Body (line 431) | Body( int nthread_, int niters_ ) : nthread(nthread_), nIters(niters_)...
  function TestLocalAllocations (line 448) | void TestLocalAllocations( int nthread ) {
  function RunLocalAllocationsTests (line 466) | void RunLocalAllocationsTests() {

FILE: third-party/tbb/test/conformance/conformance_composite_node.cpp
  class adder (line 26) | class adder : public oneapi::tbb::flow::composite_node<std::tuple<int, i...
    type f_body (line 32) | struct f_body {
    method adder (line 40) | adder(oneapi::tbb::flow::graph &g) : base_type(g), j(g), f(g, oneapi::...
  type compare (line 51) | struct compare {
    method compare_refs (line 52) | static void compare_refs(T1 tuple1, T2 tuple2) {
  type compare<1, T1, T2> (line 59) | struct compare<1, T1, T2> {
    method compare_refs (line 60) | static void compare_refs(T1 tuple1, T2 tuple2) {

FILE: third-party/tbb/test/conformance/conformance_concurrent_hash_map.cpp
  class MyException (line 36) | class MyException : public std::bad_alloc {
  class MyKey (line 44) | class MyKey {
    method MyKey (line 50) | MyKey() = default;
    method MyKey (line 51) | MyKey( const MyKey& ) = default;
    method MyKey (line 53) | static MyKey make( int i ) {
    method value_of (line 59) | int value_of() const { return key; }
  class MyData (line 65) | class MyData {
    type state_t (line 69) | enum state_t {
    method MyData (line 75) | MyData(int i = 0) {
    method MyData (line 84) | MyData( const MyData& other ) {
    method MyData (line 99) | static MyData make( int i ) {
    method value_of (line 105) | int value_of() const {
    method set_value (line 110) | void set_value( int i ) {
  class MyData2 (line 122) | class MyData2 : public MyData {
    method MyData2 (line 124) | MyData2( ) {}
    method MyData2 (line 126) | MyData2( const MyData2& other ) : MyData() {
    method MyData2 (line 132) | MyData2( const MyData& other ) {
  class MyHashCompare (line 157) | class MyHashCompare {
    method equal (line 159) | bool equal( const MyKey& j, const MyKey& k ) const {
    method hash (line 163) | std::size_t hash( const MyKey& k ) const {
  class YourHashCompare (line 168) | class YourHashCompare {
    method equal (line 170) | bool equal( const MyKey& j, const MyKey& k ) const {
    method hash (line 174) | std::size_t hash( const MyKey& ) const {
  function test_member_types (line 184) | void test_member_types() {
  function FillTable (line 221) | void FillTable( test_table_type& x, int n ) {
  function CheckTable (line 232) | static void CheckTable( const test_table_type& x, int n ) {
  function TestCopy (line 253) | void TestCopy() {
  function TestRehash (line 284) | void TestRehash() {
  function TestAssignment (line 307) | void TestAssignment() {
  function TestIteratorTraits (line 342) | void TestIteratorTraits() {
  function TestIteratorAssignment (line 350) | void TestIteratorAssignment( Iterator2 j ) {
  function TestRangeAssignment (line 360) | void TestRangeAssignment( Range2 r2 ) {
  function TestIteratorsAndRanges (line 364) | void TestIteratorsAndRanges() {
  type test_insert (line 416) | struct test_insert {
    method test (line 418) | static void test( std::initializer_list<element_type> il, container_ty...
  type ctor_test (line 425) | struct ctor_test {
    method test (line 427) | static void test( std::initializer_list<element_type> il, container_ty...
  function TestInitList (line 433) | void TestInitList(){
  class only_node_counting_allocator (line 446) | class only_node_counting_allocator : public StaticSharedCountingAllocato...
    type rebind (line 451) | struct rebind {
    method only_node_counting_allocator (line 455) | only_node_counting_allocator() : base_type() {}
    method only_node_counting_allocator (line 456) | only_node_counting_allocator(const only_node_counting_allocator& a) : ...
    method only_node_counting_allocator (line 459) | only_node_counting_allocator(const only_node_counting_allocator<U>& a)...
  function TestExceptions (line 471) | void TestExceptions() {
  type default_container_traits (line 549) | struct default_container_traits {
    method container_type (line 551) | static container_type& construct_container(typename std::aligned_stora...
    method container_type (line 558) | static container_type& construct_container(typename std::aligned_stora...
  type hash_map_traits (line 565) | struct hash_map_traits : default_container_traits {
    type hash_compare (line 569) | struct hash_compare {
      method equal (line 570) | bool equal( const T& lhs, const T& rhs ) const {
      method hash (line 573) | size_t hash( const T& k ) const {
    type apply (line 586) | struct apply {
    method equal (line 592) | static bool equal(hash_map_type const& c, iterator begin, iterator end){
  type RvalueInsert (line 608) | struct RvalueInsert {
    method apply (line 609) | static void apply( DataStateTrackedTable& table, int i ) {
  type Emplace (line 619) | struct Emplace {
    method apply_impl (line 621) | static void apply_impl( DataStateTrackedTable& table, int i) {
    method apply (line 629) | static void apply( DataStateTrackedTable& table, int i ) {
  class TableOperation (line 640) | class TableOperation {
    method TableOperation (line 647) | TableOperation( test_table_type& table ) : my_table(table) {}
  function UseKey (line 650) | bool UseKey( size_t i ) {
  type Insert (line 654) | struct Insert {
    method apply (line 655) | static void apply( test_table_type& table, int i ) {
  type Find (line 678) | struct Find {
    method apply (line 679) | static void apply( test_table_type& table, int i ) {
  type FindConst (line 700) | struct FindConst {
    method apply (line 701) | static void apply( const test_table_type& table, int i ) {
  type InsertInitList (line 715) | struct InsertInitList {
    method apply (line 716) | static void apply( test_table_type& table, int i ) {
  function DoConcurrentOperations (line 731) | void DoConcurrentOperations( TableType& table, int n, const char* what, ...
  function TraverseTable (line 737) | void TraverseTable( test_table_type& table, size_t n, size_t expected_si...
  type Erase (line 777) | struct Erase {
    method apply (line 778) | static void apply( test_table_type& table, int i ) {
  type InsertErase (line 799) | struct InsertErase  {
    method apply (line 800) | static void apply( YourTable& table, int i ) {
  type InnerInsert (line 820) | struct InnerInsert {
    method apply (line 821) | static void apply( YourTable& table, int i ) {
  type FakeExclusive (line 831) | struct FakeExclusive {
    method FakeExclusive (line 834) | FakeExclusive(utils::SpinBarrier& b, YourTable&t) : barrier(b), table(...
  type ParallelTraverseBody (line 858) | struct ParallelTraverseBody {
    method ParallelTraverseBody (line 861) | ParallelTraverseBody( AtomicByte array_[], size_t n_ ) :
  function Check (line 874) | void Check( AtomicByte array[], size_t n, size_t expected_size ) {
  function ParallelTraverseTable (line 886) | void ParallelTraverseTable( test_table_type& table, size_t n, size_t exp...
  function TestInsertFindErase (line 905) | void TestInsertFindErase( std::size_t nthread ) {
  class AddToTable (line 965) | class AddToTable {
    method AddToTable (line 970) | AddToTable( test_table_type& table, std::size_t nthread, int m ) : my_...
  class RemoveFromTable (line 1001) | class RemoveFromTable {
    method RemoveFromTable (line 1005) | RemoveFromTable( test_table_type& table, int m ) : my_table(table), my...
  function TestConcurrency (line 1024) | void TestConcurrency( std::size_t nthread ) {
  type non_default_constructible_hash_compare (line 1050) | struct non_default_constructible_hash_compare : oneapi::tbb::detail::d1:...
    method non_default_constructible_hash_compare (line 1051) | non_default_constructible_hash_compare() {
    method non_default_constructible_hash_compare (line 1055) | non_default_constructible_hash_compare(int) {}
  function TestHashCompareConstructors (line 1058) | void TestHashCompareConstructors() {
  type debug_hash_compare (line 1081) | struct debug_hash_compare : public oneapi::tbb::detail::d1::tbb_hash_com...
  function TestDeductionGuides (line 1084) | void TestDeductionGuides() {
  function test_comparisons_basic (line 1152) | void test_comparisons_basic() {
  function test_two_way_comparable_chmap (line 1165) | void test_two_way_comparable_chmap() {
  function TestCHMapComparisons (line 1176) | void TestCHMapComparisons() {
  function TestCHMapIteratorComparisonsBasic (line 1187) | void TestCHMapIteratorComparisonsBasic( CHMapType& chmap ) {
  function TestCHMapIteratorComparisons (line 1200) | void TestCHMapIteratorComparisons() {
  class HeterogeneousKey (line 1210) | class HeterogeneousKey {
    method integer_key (line 1214) | int integer_key() const { return my_key; }
    method HeterogeneousKey (line 1217) | HeterogeneousKey(int key) : my_key(key) { ++heterogeneous_keys_count; }
    method HeterogeneousKey (line 1219) | HeterogeneousKey(const HeterogeneousKey&) = delete;
    method HeterogeneousKey (line 1220) | HeterogeneousKey& operator=(const HeterogeneousKey&) = delete;
    method reset (line 1222) | static void reset() { heterogeneous_keys_count = 0; }
    type construct_flag (line 1224) | struct construct_flag {}
    method HeterogeneousKey (line 1226) | HeterogeneousKey( construct_flag, int key ) : my_key(key) {}
  type HeterogeneousHashCompare (line 1235) | struct HeterogeneousHashCompare {
    method hash (line 1239) | std::size_t hash( const HeterogeneousKey<IsConstructible>& key ) const {
    method hash (line 1243) | std::size_t hash( const int& key ) const {
    method equal (line 1247) | bool equal( const int& key1, const int& key2 ) const {
    method equal (line 1252) | bool equal( const int& key1, const HeterogeneousKey<IsConstructible>& ...
    method equal (line 1257) | bool equal( const HeterogeneousKey<IsConstructible>& key1, const int& ...
    method equal (line 1262) | bool equal( const HeterogeneousKey<IsConstructible>& key1, const Heter...
  class DefaultConstructibleValue (line 1269) | class DefaultConstructibleValue {
    method DefaultConstructibleValue (line 1271) | DefaultConstructibleValue() : my_i(default_value) {}
    method value (line 1273) | int value() const { return my_i; }
  function test_heterogeneous_find (line 1281) | void test_heterogeneous_find() {
  function test_heterogeneous_count (line 1333) | void test_heterogeneous_count() {
  function test_heterogeneous_equal_range (line 1360) | void test_heterogeneous_equal_range() {
  function test_heterogeneous_insert (line 1411) | void test_heterogeneous_insert() {
  function test_heterogeneous_erase (line 1454) | void test_heterogeneous_erase() {
  function test_heterogeneous_lookup (line 1484) | void test_heterogeneous_lookup() {

FILE: third-party/tbb/test/conformance/conformance_concurrent_map.cpp
  type AllowMultimapping<oneapi::tbb::concurrent_multimap<Args...>> (line 35) | struct AllowMultimapping<oneapi::tbb::concurrent_multimap<Args...>> : st...
  type SpecialTests<map_type> (line 44) | struct SpecialTests<map_type> {
    method Test (line 45) | static void Test() {
  type SpecialTests<multimap_type> (line 51) | struct SpecialTests<multimap_type> {
    method Test (line 52) | static void Test() {
  function test_member_types (line 58) | void test_member_types() {
  function test_deduction_guides (line 110) | void test_deduction_guides() {
  function test_heterogeneous_functions (line 143) | void test_heterogeneous_functions() {
  type COMapTraits (line 149) | struct COMapTraits : OrderedMoveTraitsBase {
  type COMultimapTraits (line 159) | struct COMultimapTraits : OrderedMoveTraitsBase {

FILE: third-party/tbb/test/conformance/conformance_concurrent_priority_queue.cpp
  function test_to_vector (line 31) | void test_to_vector() {
  function test_basic (line 44) | void test_basic() {
  function test_initializer_list (line 55) | void test_initializer_list() {
  type SpecialMemberCalls (line 61) | struct SpecialMemberCalls {
  type MoveOperationTrackerBase (line 76) | struct MoveOperationTrackerBase {
    method SpecialMemberCalls (line 82) | static SpecialMemberCalls special_member_calls() {
    method MoveOperationTrackerBase (line 88) | MoveOperationTrackerBase() : value(++value_counter) {}
    method MoveOperationTrackerBase (line 89) | explicit MoveOperationTrackerBase( const std::size_t val ) : value(val...
    method MoveOperationTrackerBase (line 92) | MoveOperationTrackerBase( const MoveOperationTrackerBase& other ) : va...
    method MoveOperationTrackerBase (line 97) | MoveOperationTrackerBase( MoveOperationTrackerBase&& other ) noexcept ...
    method MoveOperationTrackerBase (line 103) | MoveOperationTrackerBase& operator=( const MoveOperationTrackerBase& o...
    method MoveOperationTrackerBase (line 110) | MoveOperationTrackerBase& operator=( MoveOperationTrackerBase&& other ...
  type CPQSrcFixture (line 140) | struct CPQSrcFixture {
    method CPQSrcFixture (line 141) | CPQSrcFixture& operator=( const CPQSrcFixture& ) = delete;
    method init (line 151) | void init() {
    method CPQSrcFixture (line 164) | CPQSrcFixture( std::size_t size = default_container_size )
    method CPQSrcFixture (line 167) | CPQSrcFixture( const typename cpq_type::allocator_type& a, std::size_t...
  function test_steal_move_ctor (line 174) | void test_steal_move_ctor() {
  function test_steal_move_ctor_with_allocator (line 187) | void test_steal_move_ctor_with_allocator() {
  function test_per_element_move_ctor_with_allocator (line 202) | void test_per_element_move_ctor_with_allocator() {
  function test_steal_move_assign_operator (line 220) | void test_steal_move_assign_operator() {
  function test_steal_move_assign_operator_with_stateful_allocator (line 235) | void test_steal_move_assign_operator_with_stateful_allocator() {
  function test_per_element_move_assign_operator (line 252) | void test_per_element_move_assign_operator() {
  function test_cpq_move_constructor (line 271) | void test_cpq_move_constructor() {
  function test_cpq_move_assignment (line 277) | void test_cpq_move_assignment() {
  type NoDefaultCtorType (line 284) | struct NoDefaultCtorType {
    method NoDefaultCtorType (line 285) | NoDefaultCtorType() = delete;
    method NoDefaultCtorType (line 287) | NoDefaultCtorType( std::size_t val1, std::size_t val2 ) : value1(val1)...
  type ForwardInEmplaceTester (line 295) | struct ForwardInEmplaceTester {
    method ForwardInEmplaceTester (line 300) | ForwardInEmplaceTester( int val ) : a(val) {}
    method ForwardInEmplaceTester (line 301) | ForwardInEmplaceTester( const ForwardInEmplaceTester& ) = default;
    method ForwardInEmplaceTester (line 302) | ForwardInEmplaceTester( ForwardInEmplaceTester&& ) = default;
    method ForwardInEmplaceTester (line 304) | ForwardInEmplaceTester( ForwardInEmplaceTester&& obj, int val ) : a(ob...
    method ForwardInEmplaceTester (line 309) | ForwardInEmplaceTester& operator=( const ForwardInEmplaceTester& ) = d...
    method ForwardInEmplaceTester (line 311) | ForwardInEmplaceTester& operator=( ForwardInEmplaceTester&& obj ) {
  function test_move_support_in_push_pop (line 323) | void test_move_support_in_push_pop() {
  class LessA (line 379) | class LessA : public std::less<T> {
    method LessA (line 381) | explicit LessA( bool no_assert = false ) {
  function test_ctors_dtor_accessors (line 388) | void test_ctors_dtor_accessors() {
  function test_assignment_clear_swap (line 451) | void test_assignment_clear_swap() {
  function test_serial_push_pop (line 502) | void test_serial_push_pop() {
  function test_concurrent (line 530) | void test_concurrent(std::size_t n) {
  function test_multithreading (line 542) | void test_multithreading() {
  type CPQTraits (line 548) | struct CPQTraits {
  function TestDeductionGuides (line 558) | void TestDeductionGuides() {
  function TestComparisonsBasic (line 619) | void TestComparisonsBasic() {
  function TestTwoWayComparableCPQ (line 632) | void TestTwoWayComparableCPQ() {
  function TestCPQComparisons (line 643) | void TestCPQComparisons() {

FILE: third-party/tbb/test/conformance/conformance_concurrent_queue.cpp
  function push (line 46) | void push(CQ& q, ValueType v, CounterType i) {
  class ConcQWithCapacity (line 56) | class ConcQWithCapacity : public oneapi::tbb::concurrent_queue<T, test_a...
    method ConcQWithCapacity (line 59) | ConcQWithCapacity() : my_capacity( std::size_t(-1) / (sizeof(void*) + ...
    method size (line 60) | std::size_t size() const {
    method capacity (line 64) | std::size_t capacity() const {
    method set_capacity (line 68) | void set_capacity( const std::size_t n ) {
    method try_push (line 72) | bool try_push( const T& source ) {
    method try_pop (line 77) | bool try_pop( T& dest ) {
  function TestEmptyQueue (line 87) | void TestEmptyQueue() {
  function TestEmptiness (line 94) | void TestEmptiness() {
  function TestFullQueue (line 103) | void TestFullQueue() {
  function TestFullness (line 130) | void TestFullness() {
  function TestClear (line 136) | void TestClear() {
  function TestClearWorks (line 174) | void TestClearWorks() {
  function TestIteratorAux (line 180) | void TestIteratorAux( Iterator1 i, Iterator2 j, int size ) {
  function TestIteratorAssignment (line 208) | void TestIteratorAssignment( Iterator2 j ) {
  function TestIteratorTraits (line 220) | void TestIteratorTraits() {
  function TestIterator (line 232) | void TestIterator() {
  function TestQueueIteratorWorks (line 252) | void TestQueueIteratorWorks() {
  class ConcQWithSizeWrapper (line 259) | class ConcQWithSizeWrapper : public oneapi::tbb::concurrent_queue<T, A> {
    method ConcQWithSizeWrapper (line 261) | ConcQWithSizeWrapper() {}
    method ConcQWithSizeWrapper (line 262) | ConcQWithSizeWrapper( const ConcQWithSizeWrapper& q ) : oneapi::tbb::c...
    method ConcQWithSizeWrapper (line 263) | ConcQWithSizeWrapper( const ConcQWithSizeWrapper& q, const A& a ) : on...
    method ConcQWithSizeWrapper (line 264) | ConcQWithSizeWrapper( const A& a ) : oneapi::tbb::concurrent_queue<T, ...
    method ConcQWithSizeWrapper (line 266) | ConcQWithSizeWrapper( ConcQWithSizeWrapper&& q ) : oneapi::tbb::concur...
    method ConcQWithSizeWrapper (line 267) | ConcQWithSizeWrapper( ConcQWithSizeWrapper&& q, const A& a )
    method ConcQWithSizeWrapper (line 271) | ConcQWithSizeWrapper( InputIterator begin, InputIterator end, const A&...
    method size (line 273) | typename oneapi::tbb::concurrent_queue<T, A>::size_type size() const {...
  type state_type (line 276) | enum state_type {
  class Bar (line 281) | class Bar {
    method Bar (line 286) | Bar() : state(LIVE), my_id(-1)
    method Bar (line 289) | Bar( std::size_t _i ) : state(LIVE), my_id(_i) { construction_num++; }
    method Bar (line 291) | Bar( const Bar& a_bar ) : state(LIVE) {
  class BarIterator (line 321) | class BarIterator {
    method BarIterator (line 323) | BarIterator(Bar* bp_) : bar_ptr(bp_) {}
    method Bar (line 325) | Bar& operator*() const {
    method BarIterator (line 328) | BarIterator& operator++() {
    method Bar (line 332) | Bar* operator++(int) {
  class Bar_exception (line 352) | class Bar_exception : public std::bad_alloc {
  class BarEx (line 358) | class BarEx {
    method BarEx (line 372) | BarEx() : state(LIVE), my_id(-1), my_tilda_id(-1)
    method BarEx (line 375) | BarEx(std::size_t _i) : state(LIVE), my_id(_i), my_tilda_id(my_id^(-1))
    method BarEx (line 378) | BarEx( const BarEx& a_bar ) : state(LIVE) {
    method set_mode (line 393) | static void set_mode( mode_type m ) { mode = m; }
  function TestConstructors (line 417) | void TestConstructors () {
  function TestQueueConstructors (line 585) | void TestQueueConstructors() {
  type TestNegativeQueueBody (line 591) | struct TestNegativeQueueBody {
    method TestNegativeQueueBody (line 594) | TestNegativeQueueBody( oneapi::tbb::concurrent_bounded_queue<T>& q, st...
  function TestNegativeQueue (line 620) | void TestNegativeQueue( std::size_t nthread ) {
  class ConcQPushPopWrapper (line 626) | class ConcQPushPopWrapper : public oneapi::tbb::concurrent_queue<T, test...
    method ConcQPushPopWrapper (line 628) | ConcQPushPopWrapper() : my_capacity(std::size_t(-1) / (sizeof(void*) +...
    method size (line 631) | std::size_t size() const { return this->unsafe_size(); }
    method set_capacity (line 632) | void set_capacity( const ptrdiff_t n ) { my_capacity = n; }
    method try_push (line 633) | bool try_push( const T& source ) { return this->push( source); }
    method try_pop (line 634) | bool try_pop( T& dest ) { return this->oneapi::tbb::concurrent_queue<T...
  type Body (line 639) | struct Body {
    method Body (line 642) | Body( std::size_t nthread_ ) : nthread(nthread_) {}
  function TestPushPop (line 679) | void TestPushPop(typename CQ::size_type prefill, std::ptrdiff_t capacity...
  function TestConcurrentPushPop (line 752) | void TestConcurrentPushPop() {
  class Foo_exception (line 778) | class Foo_exception : public std::bad_alloc {
  class FooEx (line 791) | class FooEx {
    method FooEx (line 795) | FooEx() : state(LIVE) {
    method FooEx (line 800) | FooEx( const FooEx& item ) : state(LIVE) {
  function TestExceptionBody (line 832) | void TestExceptionBody() {
  function TestExceptions (line 923) | void TestExceptions() {
  class SimplePushBody (line 936) | class SimplePushBody {
    method SimplePushBody (line 940) | SimplePushBody(oneapi::tbb::concurrent_bounded_queue<int>* _q, std::si...
  class SimplePopBody (line 959) | class SimplePopBody {
    method SimplePopBody (line 964) | SimplePopBody(oneapi::tbb::concurrent_bounded_queue<int>* _q, std::siz...
  function TestAbort (line 986) | void TestAbort() {
  function test_member_types (line 1072) | void test_member_types() {
  type push_t (line 1104) | enum push_t { push_op, try_push_op }
  type pusher (line 1107) | struct pusher {
    method push (line 1109) | static bool push( CQ& queue, VType&& val ) {
  type pusher< try_push_op> (line 1116) | struct pusher< try_push_op> {
    method push (line 1118) | static bool push( CQ& queue, VType&& val ) {
  type pop_t (line 1123) | enum pop_t { pop_op, try_pop_op }
  type popper (line 1126) | struct popper {
    method pop (line 1128) | static bool pop( CQ& queue, VType&& val ) {
  type popper<try_pop_op> (line 1136) | struct popper<try_pop_op> {
    method pop (line 1138) | static bool pop( CQ& queue, VType&& val ) {
  type MoveOperationTracker (line 1143) | struct MoveOperationTracker {
    method MoveOperationTracker (line 1149) | MoveOperationTracker() {}
    method MoveOperationTracker (line 1150) | MoveOperationTracker(const MoveOperationTracker&) {
    method MoveOperationTracker (line 1153) | MoveOperationTracker(MoveOperationTracker&&) {
    method MoveOperationTracker (line 1156) | MoveOperationTracker& operator=(MoveOperationTracker const&) {
    method MoveOperationTracker (line 1160) | MoveOperationTracker& operator=(MoveOperationTracker&&) {
  function TestMoveSupport (line 1172) | void TestMoveSupport() {
  function TestMoveSupportInPushPop (line 1201) | void TestMoveSupportInPushPop() {
  class allocator (line 1208) | class allocator: public oneapi::tbb::cache_aligned_allocator<T> {
    method allocator (line 1213) | allocator() : m_unique_id( 0 ) {}
    method allocator (line 1214) | allocator(size_t unique_id) { m_unique_id = unique_id; }
    method allocator (line 1222) | allocator(const allocator<U>& a) noexcept {
    type rebind (line 1228) | struct rebind { typedef allocator<U> other; }
  function AssertEquality (line 1238) | void AssertEquality(Queue &q, const std::vector<typename Queue::value_ty...
  function AssertEmptiness (line 1244) | void AssertEmptiness(Queue &q) {
  function FillTest (line 1252) | void FillTest(Queue &q, const std::vector<typename Queue::value_type> &v...
  function EmptyTest (line 1259) | void EmptyTest(Queue &q, const std::vector<typename Queue::value_type> &...
  function bounded_queue_specific_test (line 1273) | void bounded_queue_specific_test(oneapi::tbb::concurrent_queue<T, A> &, ...
  function bounded_queue_specific_test (line 1276) | void bounded_queue_specific_test(oneapi::tbb::concurrent_bounded_queue<T...
  function TestQueueOperabilityAfterDataMove (line 1293) | void TestQueueOperabilityAfterDataMove( CQ& queue ) {
  function TestMoveConstructors (line 1304) | void TestMoveConstructors() {
  function TestMoveConstruction (line 1356) | void TestMoveConstruction() {
  class NonTrivialConstructorType (line 1361) | class NonTrivialConstructorType {
    method NonTrivialConstructorType (line 1363) | NonTrivialConstructorType( int a = 0 ) : m_a( a ), m_str( "" ) {}
    method NonTrivialConstructorType (line 1364) | NonTrivialConstructorType( const std::string& str ) : m_a( 0 ), m_str(...
    method NonTrivialConstructorType (line 1365) | NonTrivialConstructorType( int a, const std::string& str ) : m_a( a ),...
    method get_a (line 1366) | int get_a() const { return m_a; }
    method get_str (line 1367) | std::string get_str() const { return m_str; }
  type emplace_t (line 1373) | enum emplace_t { emplace_op, try_emplace_op }
  type emplacer (line 1376) | struct emplacer {
    method emplace (line 1378) | static void emplace( CQ& queue, Args&&... val ) { queue.emplace( std::...
  type emplacer <try_emplace_op> (line 1382) | struct emplacer <try_emplace_op> {
    method emplace (line 1384) | static void emplace( CQ& queue, Args&&... val ) {
  function TestEmplaceInQueue (line 1391) | void TestEmplaceInQueue() {
  function TestEmplace (line 1426) | void TestEmplace() {
  function TestDeductionGuides (line 1434) | void TestDeductionGuides() {
  function TestQueueIteratorComparisonsBasic (line 1465) | void TestQueueIteratorComparisonsBasic( QueueType& q ) {
  function TestQueueIteratorComparisons (line 1479) | void TestQueueIteratorComparisons() {
  class MinimalisticObject (line 1589) | class MinimalisticObject {
    type flag (line 1591) | struct flag {}
    method MinimalisticObject (line 1593) | MinimalisticObject() = delete;
    method MinimalisticObject (line 1594) | MinimalisticObject(flag) : underlying_obj(default_obj) {}
    method MinimalisticObject (line 1596) | MinimalisticObject(const MinimalisticObject&) = delete;
    method MinimalisticObject (line 1597) | MinimalisticObject& operator=(const MinimalisticObject&) = delete;
    method get_obj (line 1599) | std::size_t get_obj() const { return underlying_obj; }
    method get_default_obj (line 1600) | std::size_t get_default_obj() const { return default_obj; }
  type MoveAssignableMinimalisticObject (line 1608) | struct MoveAssignableMinimalisticObject : MinimalisticObject {
    method MoveAssignableMinimalisticObject (line 1612) | MoveAssignableMinimalisticObject& operator=(MoveAssignableMinimalistic...
  function test_basics (line 1622) | void test_basics(Container& container, std::size_t desired_size) {
  function test_with_minimalistic_objects (line 1637) | void test_with_minimalistic_objects() {
  function test_queue_helper (line 1685) | void test_queue_helper() {
  function TestMoveQueue (line 1719) | void TestMoveQueue() {
  type stateful_allocator (line 1754) | struct stateful_allocator {
    method stateful_allocator (line 1756) | stateful_allocator() = default;
    method stateful_allocator (line 1759) | constexpr stateful_allocator(const stateful_allocator<U>& src) noexcep...
    method T (line 1761) | T* allocate(std::size_t n) {
    method deallocate (line 1765) | void deallocate(T* p, std::size_t) noexcept {
  function TestMoveQueueUnequal (line 1777) | void TestMoveQueueUnequal() {
  function test_check_move_allocator (line 1815) | void test_check_move_allocator(Container& src, Container& dst, Container...
  function test_move_assignment_test_equal (line 1820) | void test_move_assignment_test_equal() {
  function test_move_assignment_test_unequal (line 1845) | void test_move_assignment_test_unequal() {

FILE: third-party/tbb/test/conformance/conformance_concurrent_set.cpp
  type AllowMultimapping<oneapi::tbb::concurrent_multiset<Args...>> (line 31) | struct AllowMultimapping<oneapi::tbb::concurrent_multiset<Args...>> : st...
  function test_member_types (line 40) | void test_member_types() {
  function test_deduction_guides (line 90) | void test_deduction_guides() {
  function test_heterogeneous_functions (line 124) | void test_heterogeneous_functions() {
  type COSetTraits (line 130) | struct COSetTraits : OrderedMoveTraitsBase {
  type COMultisetTraits (line 140) | struct COMultisetTraits : OrderedMoveTraitsBase {

FILE: third-party/tbb/test/conformance/conformance_concurrent_unordered_map.cpp
  type AllowMultimapping<oneapi::tbb::concurrent_unordered_multimap<Args...>> (line 32) | struct AllowMultimapping<oneapi::tbb::concurrent_unordered_multimap<Args...
  type SpecialTests<map_type> (line 41) | struct SpecialTests<map_type> {
    method Test (line 42) | static void Test() {
  type SpecialTests<multimap_type> (line 48) | struct SpecialTests<multimap_type> {
    method Test (line 49) | static void Test() {
  function test_member_types (line 55) | void test_member_types() {
  function test_deduction_guides (line 128) | void test_deduction_guides() {
  function test_heterogeneous_functions (line 217) | void test_heterogeneous_functions() {
  type CumapTraits (line 224) | struct CumapTraits : UnorderedMoveTraitsBase {
  type CumultimapTraits (line 234) | struct CumultimapTraits : UnorderedMoveTraitsBase {

FILE: third-party/tbb/test/conformance/conformance_concurrent_unordered_set.cpp
  type AllowMultimapping<oneapi::tbb::concurrent_unordered_multiset<Args...>> (line 33) | struct AllowMultimapping<oneapi::tbb::concurrent_unordered_multiset<Args...
  function test_member_types (line 42) | void test_member_types() {
  type CusetTraits (line 109) | struct CusetTraits : UnorderedMoveTraitsBase {
  type CumultisetTraits (line 119) | struct CumultisetTraits : UnorderedMoveTraitsBase {
  function test_deduction_guides (line 131) | void test_deduction_guides() {

FILE: third-party/tbb/test/conformance/conformance_concurrent_vector.cpp
  function CheckConstIterator (line 40) | void CheckConstIterator( const Vector& u, int i, const Iterator& cp ) {
  function CheckIteratorComparison (line 50) | void CheckIteratorComparison( V& u ) {
  function TestIteratorAssignment (line 75) | void TestIteratorAssignment( Iterator2 j ) {
  function TestRangeAssignment (line 86) | void TestRangeAssignment( Range2 r2 ) {
  function TestSequentialFor (line 91) | void TestSequentialFor() {
  function NextSize (line 220) | inline void NextSize( int& s ) {
  function T (line 227) | inline T* end( T(& array)[N]) {
  function CheckVector (line 232) | static void CheckVector( const vector_t& cv, std::size_t expected_size, ...
  function TestResizeAndCopy (line 241) | void TestResizeAndCopy() {
  function TestCopyAssignment (line 289) | void TestCopyAssignment() {
  function TestGrowToAtLeastWithSourceParameter (line 324) | void TestGrowToAtLeastWithSourceParameter(T const& src){
  function TestCapacity (line 332) | void TestCapacity() {
  function get_early_size (line 370) | std::size_t get_early_size(c_vector & v){
  function verify_c_vector_size (line 374) | void verify_c_vector_size(std::size_t size, std::size_t capacity, std::s...
  function verify_c_vector_size (line 380) | void verify_c_vector_size(c_vector_t & c_v){
  function TestExceptions (line 385) | void TestExceptions() {
  function verify_c_vector_capacity_is_below (line 497) | void verify_c_vector_capacity_is_below(size_t capacity, size_t high){
  function verify_vector_partially_copied (line 503) | void verify_vector_partially_copied(
  function verify_last_segment_allocation_failed (line 517) | void verify_last_segment_allocation_failed(vector_t const& victim){
  function verify_copy_and_assign_from_produce_the_same (line 523) | void verify_copy_and_assign_from_produce_the_same(vector_t const& victim){
  function verify_assignment_operator_throws_bad_last_alloc (line 533) | void verify_assignment_operator_throws_bad_last_alloc(vector_t & victim){
  function test_ex_assign_operator (line 546) | void test_ex_assign_operator(){
  function AssertSameType (line 586) | void AssertSameType( const T& /*x*/, const T& /*y*/ ) {}
  type test_grow_by (line 588) | struct test_grow_by {
    method test (line 590) | static void test( std::initializer_list<element_type> const& il, conta...
  function TestIteratorTraits (line 598) | void TestIteratorTraits() {
  function TestInitList (line 609) | void TestInitList() {
  type TestMoveInShrinkToFitHelpers (line 615) | namespace TestMoveInShrinkToFitHelpers {
    type dummy (line 616) | struct dummy : StateTrackable<>{
      method dummy (line 618) | dummy(int an_i) noexcept : StateTrackable<>(0), i(an_i) {}
  function TestSerialMoveInShrinkToFit (line 624) | void TestSerialMoveInShrinkToFit(){
  type default_container_traits (line 649) | struct default_container_traits {
    method container_type (line 651) | static container_type& construct_container(typename std::aligned_stora...
    method container_type (line 658) | static container_type& construct_container(typename std::aligned_stora...
  type c_vector_type (line 665) | struct c_vector_type : default_container_traits {
    type apply (line 674) | struct apply{
    method equal (line 681) | static bool equal(oneapi::tbb::concurrent_vector<element_type, allocat...
  function TestSerialGrowByWithMoveIterators (line 687) | void TestSerialGrowByWithMoveIterators(){
  type test_grow_to_at_least_helpers (line 699) | namespace test_grow_to_at_least_helpers {
    class GrowToAtLeast (line 701) | class GrowToAtLeast {
      method GrowToAtLeast (line 727) | GrowToAtLeast(bool use_two_args_form, MyVector& vector, const_refere...
  function TestConcurrentGrowToAtLeastImpl (line 733) | void TestConcurrentGrowToAtLeastImpl() {
  type AssignElement (line 754) | struct AssignElement {
    method AssignElement (line 765) | AssignElement( iterator base_ ) : base(base_) {}
  type CheckElement (line 768) | struct CheckElement {
    method CheckElement (line 778) | CheckElement( iterator base_ ) : base(base_) {}
  function TestParallelFor (line 782) | void TestParallelFor( std::size_t nthread ) {
  type grain_map (line 803) | struct grain_map {
    type grow_method_enum (line 804) | enum grow_method_enum {
    type range_part (line 815) | struct range_part {
    method grain_map (line 826) | grain_map(const range_part* begin, const range_part* end)
    type sum_number_of_parts (line 833) | struct sum_number_of_parts{
      method sum (line 834) | static std::size_t sum(std::size_t accumulator, grain_map::range_par...
    method separate (line 838) | static std::vector<range_part> separate(const range_part* begin, const...
    type distributed (line 847) | struct distributed {
      method is_not (line 848) | static bool is_not(range_part const& rp){ return !rp.distribute;}
      method is_yes (line 849) | static bool is_yes(range_part const& rp){ return rp.distribute;}
  class GrowBy (line 856) | class GrowBy {
    type not_zero (line 908) | struct not_zero{
      method is (line 909) | static bool is(std::size_t items_to_add){ return items_to_add != 0;}
    method GrowBy (line 947) | GrowBy( MyVector& vector, const grain_map& m, std::size_t part_weight )
  function TestConcurrentGrowBy (line 953) | void TestConcurrentGrowBy() {
  function TestComparison (line 1039) | void TestComparison() {
  function test_ex_move_assignment_memory_failure (line 1061) | void test_ex_move_assignment_memory_failure() {
  function test_ex_move_assignment_element_ctor_exception (line 1092) | void test_ex_move_assignment_element_ctor_exception(){
  function test_ex_move_assignment (line 1121) | void test_ex_move_assignment() {
  class test_grow_by_and_resize (line 1128) | class test_grow_by_and_resize {
    method test_grow_by_and_resize (line 1131) | test_grow_by_and_resize( oneapi::tbb::concurrent_vector<Type, Allocato...
  type push_back_exception_safety_helpers (line 1141) | namespace push_back_exception_safety_helpers {
    type throwing_foo (line 1143) | struct throwing_foo:move_support_tests::Foo {
      method throwing_foo (line 1146) | explicit throwing_foo(int v1, int v2) : value1 (v1), value2(v2) {}
    type fixture (line 1150) | struct fixture {
      method test (line 1154) | void test( void(*p_test)(vector_t&)){
  function TestPushBackMoveExceptionSafety (line 1165) | void TestPushBackMoveExceptionSafety() {
  function TestEmplaceBackExceptionSafety (line 1180) | void TestEmplaceBackExceptionSafety(){
  type move_semantics_helpers (line 1196) | namespace move_semantics_helpers {
    type move_only_type (line 1197) | struct move_only_type {
      method move_only_type (line 1199) | move_only_type(move_only_type && other): my_pointer(other.my_pointer...
      method move_only_type (line 1200) | explicit move_only_type(const int* value): my_pointer(value) {}
  function TestPushBackMoveOnlyContainer (line 1204) | void TestPushBackMoveOnlyContainer(){
  function TestDeductionGuides (line 1217) | void TestDeductionGuides() {
  function test_member_types (line 1261) | void test_member_types() {
  function TestConcurrentGrowToAtLeast (line 1301) | void TestConcurrentGrowToAtLeast() {
  function test_comparisons_basic (line 1307) | void test_comparisons_basic() {
  function test_two_way_comparable_vector (line 1327) | void test_two_way_comparable_vector() {
  function test_three_way_comparable_vector (line 1344) | void test_three_way_comparable_vector() {
  function TestVectorComparisons (line 1366) | void TestVectorComparisons() {
  function DoVectorIteratorComparisons (line 1387) | void DoVectorIteratorComparisons( const Iterator& lhs, const Iterator& r...
  function TestVectorIteratorComparisonsBasic (line 1395) | void TestVectorIteratorComparisonsBasic( VectorType& vec ) {
  function TestVectorIteratorComparisons (line 1406) | void TestVectorIteratorComparisons() {

FILE: third-party/tbb/test/conformance/conformance_continue_node.cpp
  function test_deduction_guides_common (line 33) | void test_deduction_guides_common(Body body) {
  function continue_body_f (line 93) | int continue_body_f(const tbb::flow::continue_msg&) { return 1; }
  function continue_void_body_f (line 94) | void continue_void_body_f(const tbb::flow::continue_msg&) {}
  function test_deduction_guides (line 96) | void test_deduction_guides() {

FILE: third-party/tbb/test/conformance/conformance_enumerable_thread_specific.cpp
  class minimalNComparable (line 75) | class minimalNComparable: utils::NoAssign {
    method minimalNComparable (line 81) | minimalNComparable() : utils::NoAssign(), my_value(0) { ++construction...
    method minimalNComparable (line 82) | minimalNComparable( const minimalNComparable &m ) : utils::NoAssign(),...
    method set_value (line 84) | void set_value( const int i ) { CHECK_FAST(is_constructed); my_value =...
    method value (line 85) | int value( ) const { CHECK_FAST(is_constructed); return my_value; }
  function T (line 93) | T& check_alignment(T& t, const char *aname) {
  function T (line 102) | const T& check_alignment(const T& t, const char *aname) {
  class Thrower (line 117) | class Thrower {
    method Thrower (line 119) | Thrower() {
  class ThrowingConstructor (line 131) | class ThrowingConstructor {
    method ThrowingConstructor (line 136) | ThrowingConstructor() : m_checktype(), m_throwing_field() { m_cnt = 0;}
  type test_helper (line 148) | struct test_helper {
    method init (line 149) | static inline void init(T &e) { e = static_cast<T>(0); }
    method sum (line 150) | static inline void sum(T &e, const int addend ) { e += static_cast<T>(...
    method sum (line 151) | static inline void sum(T &e, const double addend ) { e += static_cast<...
    method set (line 152) | static inline void set(T &e, const int value ) { e = static_cast<T>(va...
    method get (line 153) | static inline double get(const T &e ) { return static_cast<double>(e); }
  type test_helper<minimalNComparable<N> > (line 157) | struct test_helper<minimalNComparable<N> > {
    method init (line 158) | static inline void init(minimalNComparable<N> &sum) { sum.set_value( 0...
    method sum (line 159) | static inline void sum(minimalNComparable<N> &sum, const int addend ) ...
    method sum (line 160) | static inline void sum(minimalNComparable<N> &sum, const double addend...
    method sum (line 161) | static inline void sum(minimalNComparable<N> &sum, const minimalNCompa...
    method set (line 162) | static inline void set(minimalNComparable<N> &v, const int value ) { v...
    method get (line 163) | static inline double get(const minimalNComparable<N> &sum ) { return s...
  type test_helper<ThrowingConstructor> (line 167) | struct test_helper<ThrowingConstructor> {
    method init (line 168) | static inline void init(ThrowingConstructor &sum) { sum.m_cnt = 0; }
    method sum (line 169) | static inline void sum(ThrowingConstructor &sum, const int addend ) { ...
    method sum (line 170) | static inline void sum(ThrowingConstructor &sum, const double addend )...
    method sum (line 171) | static inline void sum(ThrowingConstructor &sum, const ThrowingConstru...
    method set (line 172) | static inline void set(ThrowingConstructor &v, const int value ) { v.m...
    method get (line 173) | static inline double get(const ThrowingConstructor &sum ) { return sta...
  type SecretTagType (line 177) | struct SecretTagType {}
  type FunctorFinit (line 185) | struct FunctorFinit {
    method FunctorFinit (line 186) | FunctorFinit( const FunctorFinit& ) {++FinitCounter;}
    method FunctorFinit (line 187) | FunctorFinit( SecretTagType ) {++FinitCounter;}
    method T (line 189) | T operator()() { return Value; }
  type FunctorFinit<ThrowingConstructor,Value> (line 193) | struct FunctorFinit<ThrowingConstructor,Value> {
    method FunctorFinit (line 194) | FunctorFinit( const FunctorFinit& ) {++FinitCounter;}
    method FunctorFinit (line 195) | FunctorFinit( SecretTagType ) {++FinitCounter;}
    method ThrowingConstructor (line 197) | ThrowingConstructor operator()() { ThrowingConstructor temp; temp.m_cn...
  type FunctorFinit<minimalNComparable<N>,Value> (line 201) | struct FunctorFinit<minimalNComparable<N>,Value> {
    method FunctorFinit (line 202) | FunctorFinit( const FunctorFinit& ) {++FinitCounter;}
    method FunctorFinit (line 203) | FunctorFinit( SecretTagType ) {++FinitCounter;}
  type FunctorAddCombineRef (line 215) | struct FunctorAddCombineRef {
    method T (line 216) | T operator()(const T& left, const T& right) const {
  type FunctorAddCombineRef<minimalNComparable<N> > (line 222) | struct FunctorAddCombineRef<minimalNComparable<N> > {
  type FunctorAddCombineRef<ThrowingConstructor> (line 231) | struct FunctorAddCombineRef<ThrowingConstructor> {
    method ThrowingConstructor (line 232) | ThrowingConstructor operator()(const ThrowingConstructor& left, const ...
  type FunctorAddCombine (line 240) | struct FunctorAddCombine {
    method T (line 241) | T operator()(T left, T right ) const {
  function T (line 247) | T FunctionAddByRef( const T &left, const T &right) {
  function T (line 252) | T FunctionAdd( T left, T right) { return FunctionAddByRef(left,right); }
  class Accumulator (line 255) | class Accumulator {
    method Accumulator (line 257) | Accumulator(T& result) : my_result(result) {}
    method Accumulator (line 258) | Accumulator(const Accumulator& other) : my_result(other.my_result) {}
    method Accumulator (line 259) | Accumulator& operator=(const Accumulator& other) {
  class ClearingAccumulator (line 269) | class ClearingAccumulator {
    method ClearingAccumulator (line 271) | ClearingAccumulator(T& result) : my_result(result) {}
    method ClearingAccumulator (line 272) | ClearingAccumulator(const ClearingAccumulator& other) : my_result(othe...
    method ClearingAccumulator (line 273) | ClearingAccumulator& operator=(const ClearingAccumulator& other) {
    method AssertClean (line 281) | static void AssertClean(const T& thread_local_value) {
  class parallel_scalar_body (line 298) | class parallel_scalar_body: utils::NoAssign {
    method parallel_scalar_body (line 305) | parallel_scalar_body ( ets_type &_sums, const char *alloc_name ) : sum...
  function run_parallel_scalar_tests_nocombine (line 315) | void run_parallel_scalar_tests_nocombine(const char* /* test_name */, co...
  function run_parallel_scalar_tests (line 485) | void run_parallel_scalar_tests(const char* test_name, const char* alloca...
  class parallel_vector_for_body (line 587) | class parallel_vector_for_body: utils::NoAssign {
    method parallel_vector_for_body (line 595) | parallel_vector_for_body ( ets_type &_locals, const char *aname ) : lo...
  type parallel_vector_reduce_body (line 609) | struct parallel_vector_reduce_body {
    method parallel_vector_reduce_body (line 615) | parallel_vector_reduce_body ( ) : count(0) { test_helper<T>::init(sum); }
    method parallel_vector_reduce_body (line 616) | parallel_vector_reduce_body ( parallel_vector_reduce_body<R, T> &, one...
    method join (line 628) | void join( const parallel_vector_reduce_body &b ) {
  function run_parallel_vector_tests (line 636) | void run_parallel_vector_tests(const char* /* test_name */, const char *...
  function run_cross_type_vector_tests (line 721) | void run_cross_type_vector_tests(const char* /* test_name */) {
  function run_serial_scalar_tests (line 780) | void run_serial_scalar_tests(const char* /* test_name */) {
  function run_serial_vector_tests (line 795) | void run_serial_vector_tests(const char* /* test_name */) {
  function run_reference_check (line 816) | void run_reference_check() {
  function run_parallel_tests (line 825) | void run_parallel_tests(const char *allocator_name) {
  function run_cross_type_tests (line 834) | void run_cross_type_tests() {
  function MakeETS (line 841) | oneapi::tbb::enumerable_thread_specific<T,Allocator<T> > MakeETS( Init i...
  type MakeETS_Functor (line 846) | struct MakeETS_Functor {
    method ETS (line 847) | ETS operator()( typename std::decay<P>::type&&... params ) {
  function MakeETS (line 852) | oneapi::tbb::enumerable_thread_specific<T,Allocator<T> > MakeETS( oneapi...
  function ets_copy_assign_test (line 860) | void ets_copy_assign_test( InitSrc init1, InitDst init2, Validator check...
  type Validator (line 908) | struct Validator {
  function run_assign_and_copy_constructor_test (line 919) | void run_assign_and_copy_constructor_test(const char* /* test_name */, c...
  function run_assignment_and_copy_constructor_tests (line 942) | void run_assignment_and_copy_constructor_tests(const char* allocator_nam...
  class HasNoDefaultConstructor (line 953) | class HasNoDefaultConstructor {
    method HasNoDefaultConstructor (line 956) | HasNoDefaultConstructor( SecretTagType ) {}
  type HasNoDefaultConstructorFinit (line 959) | struct HasNoDefaultConstructorFinit {
    method HasNoDefaultConstructor (line 960) | HasNoDefaultConstructor operator()() {
  type HasNoDefaultConstructorCombine (line 965) | struct HasNoDefaultConstructorCombine {
    method HasNoDefaultConstructor (line 966) | HasNoDefaultConstructor operator()( HasNoDefaultConstructor, HasNoDefa...
  class HasSpecialAndMoveCtor (line 972) | class HasSpecialAndMoveCtor : utils::NoCopy {
    method HasSpecialAndMoveCtor (line 975) | HasSpecialAndMoveCtor( SecretTagType, size_t = size_t(0), const char* ...
    method HasSpecialAndMoveCtor (line 976) | HasSpecialAndMoveCtor( HasSpecialAndMoveCtor&& ) {}
  type EmptyCombineEach (line 981) | struct EmptyCombineEach {
  function TestInstantiation (line 987) | void TestInstantiation(const char* /* allocator_name */) {
  function TestMemberTypes (line 1020) | void TestMemberTypes() {
  function init_tbb_alloc_mask (line 1061) | size_t init_tbb_alloc_mask() {
  function TestETSIterator (line 1077) | void TestETSIterator() {
  function DoETSIteratorComparisons (line 1152) | void DoETSIteratorComparisons( const Iterator& lhs, const Iterator& rhs ) {
  function TestETSIteratorComparisonsBasic (line 1160) | void TestETSIteratorComparisonsBasic( ETS& ets ) {
  function TestETSIteratorComparisons (line 1171) | void TestETSIteratorComparisons() {

FILE: third-party/tbb/test/conformance/conformance_flowgraph.h
  function namespace (line 29) | namespace conformance {
  function OutputType (line 359) | OutputType operator()( InputType ) {
  function OutputType (line 371) | OutputType operator()( oneapi::tbb::flow_control & fc ) {
  function OutputType (line 385) | OutputType operator()( const oneapi::tbb::flow::continue_msg& ) {
  function OutputType (line 389) | OutputType operator()( const OutputType& i ) {
  function OutputType (line 393) | OutputType operator()( oneapi::tbb::flow_control & fc ) {

FILE: third-party/tbb/test/conformance/conformance_function_node.cpp
  function function_body_f (line 35) | int function_body_f(const int&) { return 1; }
  function test_deduction_guides_common (line 38) | void test_deduction_guides_common(Body body) {
  function test_deduction_guides (line 72) | void test_deduction_guides() {
  function test_fn_invoke_basic (line 84) | void test_fn_invoke_basic(const Body1& body1, const Body2& body2) {
  function test_fn_invoke (line 106) | void test_fn_invoke() {

FILE: third-party/tbb/test/conformance/conformance_global_control.cpp
  function TestStackSizeSimpleControl (line 34) | void TestStackSizeSimpleControl() {
  type StackSizeRun (line 45) | struct StackSizeRun : utils::NoAssign {
    method StackSizeRun (line 50) | StackSizeRun(int threads, utils::SpinBarrier *b1, utils::SpinBarrier *...
  function TestStackSizeThreadsControl (line 62) | void TestStackSizeThreadsControl() {
  function RunWorkersLimited (line 68) | void RunWorkersLimited(size_t parallelism)
  function TestWorkersConstraints (line 80) | void TestWorkersConstraints()
  type SetUseRun (line 102) | struct SetUseRun: utils::NoAssign {
    method SetUseRun (line 105) | SetUseRun(utils::SpinBarrier& b) : barr(b) {}
  function TestConcurrentSetUseConcurrency (line 121) | void TestConcurrentSetUseConcurrency()
  function TestAutoInit (line 128) | void TestAutoInit()
  class TestMultipleControlsRun (line 148) | class TestMultipleControlsRun {
    method TestMultipleControlsRun (line 151) | TestMultipleControlsRun(utils::SpinBarrier& b) : barrier(b) {}
  function TestMultipleControls (line 187) | void TestMultipleControls()

FILE: third-party/tbb/test/conformance/conformance_graph.cpp
  function test_continue_node_rf_reset_protocol (line 26) | void test_continue_node_rf_reset_protocol(){
  function test_input_node_rf_reset_protocol (line 49) | void test_input_node_rf_reset_protocol(){
  function test_functional_nodes_rf_reset_protocol (line 69) | void test_functional_nodes_rf_reset_protocol(){
  function test_buffering_nodes_rf_reset_protocol (line 87) | void test_buffering_nodes_rf_reset_protocol(Args... node_body){
  function test_nodes_with_body_rf_reset_bodies (line 106) | void test_nodes_with_body_rf_reset_bodies(Args... node_args){
  function test_limiter_node_rf_reset_protocol (line 123) | void test_limiter_node_rf_reset_protocol(){
  function test_join_node_rf_reset_protocol (line 147) | void test_join_node_rf_reset_protocol(){

FILE: third-party/tbb/test/conformance/conformance_input_node.cpp
  function input_body_f (line 31) | int input_body_f(tbb::flow_control&) { return 42; }
  function test_deduction_guides (line 33) | void test_deduction_guides() {
  function test_inheritance (line 72) | void test_inheritance(){
  type input_node_counter (line 196) | struct input_node_counter{
    method input_node_counter (line 199) | input_node_counter(int n) : N(n){}
  type function_node_counter (line 211) | struct function_node_counter{

FILE: third-party/tbb/test/conformance/conformance_join_node.cpp
  function get_values (line 30) | std::vector<my_input_tuple> get_values( conformance::test_push_receiver<...
  function test_deduction_guides (line 40) | void test_deduction_guides() {
  type MyHash (line 201) | struct MyHash{
    method hash (line 202) | std::size_t hash(const KeyType &k) const {
    method equal (line 206) | bool equal(const KeyType &k1, const KeyType &k2) const{
  function test_invoke_basic (line 272) | void test_invoke_basic(Body1 body1, Body2 body2) {

FILE: third-party/tbb/test/conformance/conformance_multifunction_node.cpp
  function test_inheritance (line 36) | void test_inheritance(){

FILE: third-party/tbb/test/conformance/conformance_mutex.h
  function increment (line 129) | void increment() {
  function value_is (line 135) | bool value_is(long expected_value) const {
  function class (line 235) | class scoped_lock {
  function acquire (line 279) | void acquire(mutex_type& m, bool is_writer) {
  function try_acquire (line 285) | bool try_acquire(mutex_type& m, bool is_writer) {
  function upgrade_to_writer (line 294) | bool upgrade_to_writer() {
  function downgrade_to_reader (line 302) | bool downgrade_to_reader() {
  function recurse_till (line 322) | void recurse_till(std::size_t i, std::size_t till) const {
  function const (line 338) | void operator()(oneapi::tbb::blocked_range<std::size_t>& range) const {
  function counter (line 342) | counter(counter_) {
  function const (line 351) | void operator()(oneapi::tbb::blocked_range<std::size_t>& range) const {

FILE: third-party/tbb/test/conformance/conformance_parallel_for.cpp
  type parallel_tag (line 36) | struct parallel_tag {}
  type empty_partitioner_tag (line 37) | struct empty_partitioner_tag {}
  class TestFunctor (line 46) | class TestFunctor{
  class FooRange (line 57) | class FooRange {
    method FooRange (line 63) | FooRange( int start_, int size_ ) : start(start_), size(size_) {
    method empty (line 73) | bool empty() const {return size==0;}
    method is_divisible (line 74) | bool is_divisible() const {return size>1;}
    method FooRange (line 75) | FooRange( FooRange& original, oneapi::tbb::split ) : size(original.siz...
  class FooBody (line 85) | class FooBody {
    method FooBody (line 93) | FooBody( const FooBody& other ) : array(other.array), state(other.stat...
    method FooBody (line 109) | FooBody( std::atomic<int>* array_ ) : array(array_), state(LIVE) {}
  type Invoker (line 113) | struct Invoker
  type Invoker<parallel_tag, empty_partitioner_tag, Range, Body> (line 116) | struct Invoker<parallel_tag, empty_partitioner_tag, Range, Body> {
  type Invoker<parallel_tag, Partitioner, Range, Body> (line 123) | struct Invoker<parallel_tag, Partitioner, Range, Body> {
  type InvokerStep (line 130) | struct InvokerStep
  type InvokerStep<parallel_tag, empty_partitioner_tag, T, Body> (line 133) | struct InvokerStep<parallel_tag, empty_partitioner_tag, T, Body> {
  type InvokerStep<parallel_tag, Partitioner, T, Body> (line 143) | struct InvokerStep<parallel_tag, Partitioner, T, Body> {
  function Flog (line 153) | void Flog() {
  function TestParallelForWithStepSupportHelper (line 198) | void TestParallelForWithStepSupportHelper(Partitioner& p) {
  function TestParallelForWithStepSupport (line 230) | void TestParallelForWithStepSupport() {
  class SmartIndex (line 249) | class SmartIndex {
    method SmartIndex (line 251) | SmartIndex(std::size_t ri) : real_index(ri), change_vector(nullptr) {}
    method SmartIndex (line 252) | SmartIndex(std::size_t ri, std::vector<std::size_t>& cv)
    method SmartIndex (line 254) | SmartIndex(const SmartIndex& other) : real_index(other.real_index),
    method SmartIndex (line 258) | SmartIndex& operator=(const SmartIndex& other) {
    method SmartIndex (line 272) | SmartIndex operator/(const SmartIndex& other) const {
    method SmartIndex (line 276) | SmartIndex operator*(const SmartIndex& other) const {
    method SmartIndex (line 280) | SmartIndex operator+(const SmartIndex& other) const {
    method SmartIndex (line 284) | SmartIndex& operator+=(const SmartIndex& other) {
    method SmartIndex (line 289) | SmartIndex& operator++() { ++real_index; return *this; }
    method SmartIndex (line 295) | SmartIndex operator+(std::size_t k) {
    method increase (line 299) | void increase() const {
  function test_pfor_body_invoke (line 308) | void test_pfor_body_invoke() {
  function test_pfor_func_invoke (line 329) | void test_pfor_func_invoke() {

FILE: third-party/tbb/test/conformance/conformance_parallel_for_each.cpp
  type set_to (line 52) | struct set_to {
  function WorkProducingTest (line 64) | void WorkProducingTest(Context&... context) {
  class ForEachInvokeItem (line 96) | class ForEachInvokeItem {
    method ForEachInvokeItem (line 98) | ForEachInvokeItem(std::size_t rv, std::vector<std::size_t>& cv) : real...
    method do_action (line 100) | void do_action() const { ++change_vector[real_value]; }
    method do_action_and_feed (line 102) | void do_action_and_feed(oneapi::tbb::feeder<ForEachInvokeItem>& feeder...
  function test_pfor_each_invoke_basic (line 116) | void test_pfor_each_invoke_basic() {

FILE: third-party/tbb/test/conformance/conformance_parallel_invoke.cpp
  type correctness_test_case (line 37) | struct correctness_test_case {
    type functor (line 42) | struct functor {
      method functor (line 44) | functor() = default;
      method functor (line 45) | functor(const functor&) = delete;
      method functor (line 46) | functor& operator=(const functor&) = delete;
    method run_validate_and_reset (line 54) | static void run_validate_and_reset(oneapi::tbb::task_group_context* co...
  function correctness_test (line 69) | void correctness_test(oneapi::tbb::task_group_context* context_ptr = nul...
  type exception_handling_test_case (line 109) | struct exception_handling_test_case {
    type functor (line 112) | struct functor {
      method functor (line 113) | functor() = default;
      method functor (line 114) | functor(const functor&) = delete;
      method functor (line 115) | functor& operator=(const functor&) = delete;
    method run_validate_and_reset (line 125) | static void run_validate_and_reset() {
  function function_to_cancel (line 163) | void function_to_cancel() {
  function simple_test_nothrow (line 169) | void simple_test_nothrow (){
  type ParInvokeLauncher (line 175) | struct ParInvokeLauncher {
    method ParInvokeLauncher (line 188) | ParInvokeLauncher ( oneapi::tbb::task_group_context& ctx ) : my_ctx(ct...

FILE: third-party/tbb/test/conformance/conformance_parallel_pipeline.cpp
  class input_filter (line 44) | class input_filter {
    method U (line 46) | U operator()( oneapi::tbb::flow_control& control ) const {
  class middle_filter (line 56) | class middle_filter {
    method U (line 58) | U operator()(T) const {
  class output_filter (line 65) | class output_filter {
  function TestSingleFilter (line 75) | void TestSingleFilter(Body body, Cotnext&... context) {
  function TestSingleFilterFunctor (line 90) | void TestSingleFilterFunctor() {
  function TestSingleFilterLambda (line 101) | void TestSingleFilterLambda() {
  function RunPipeline (line 121) | void RunPipeline(const oneapi::tbb::filter<I, O> &filter)
  function RunPipeline (line 140) | void RunPipeline(const oneapi::tbb::filter<void, void> &filter)
  function RootSequence (line 146) | void RootSequence( Iterator1 first, Iterator1 last, Iterator2 res) {
  function doWork (line 270) | void doWork() {
  type print (line 375) | struct print
  function test_pipeline_invoke_basic (line 406) | void test_pipeline_invoke_basic(const MiddleFilterBody& middle_body, con...

FILE: third-party/tbb/test/conformance/conformance_parallel_reduce.cpp
  class RotOp (line 27) | class RotOp {
    method join (line 33) | int join( int x, int y ) const {
  type ReduceBody (line 39) | struct ReduceBody {
    method ReduceBody (line 43) | ReduceBody() : my_value() {}
    method ReduceBody (line 44) | ReduceBody( ReduceBody &, oneapi::tbb::split ) : my_value() {}
    method join (line 54) | void join( const ReduceBody& y ) {
  class MoveOnlyWrapper (line 61) | class MoveOnlyWrapper {
    method MoveOnlyWrapper (line 63) | MoveOnlyWrapper() = default;
    method MoveOnlyWrapper (line 64) | MoveOnlyWrapper(const T& obj) : my_obj(obj) {}
    method MoveOnlyWrapper (line 66) | MoveOnlyWrapper(MoveOnlyWrapper&&) = default;
    method MoveOnlyWrapper (line 67) | MoveOnlyWrapper& operator=(MoveOnlyWrapper&&) = default;
    method MoveOnlyWrapper (line 69) | MoveOnlyWrapper(const MoveOnlyWrapper&) = delete;
    method MoveOnlyWrapper (line 70) | MoveOnlyWrapper& operator=(const MoveOnlyWrapper&) = delete;
  class EmptyCopyList (line 82) | class EmptyCopyList {
    method EmptyCopyList (line 84) | EmptyCopyList() = default;
    method EmptyCopyList (line 86) | EmptyCopyList(EmptyCopyList&&) = default;
    method EmptyCopyList (line 87) | EmptyCopyList& operator=(EmptyCopyList&&) = default;
    method EmptyCopyList (line 89) | EmptyCopyList(const EmptyCopyList& other) {
    method EmptyCopyList (line 92) | EmptyCopyList& operator=(const EmptyCopyList& other) {
    method insert (line 97) | typename std::list<T>::iterator insert(typename std::list<T>::const_it...
    method splice (line 101) | void splice(typename std::list<T>::const_iterator pos, EmptyCopyList&&...
    method end (line 105) | typename std::list<T>::const_iterator end() const { return my_list.end...
  function TestDeterministicReductionFor (line 114) | void TestDeterministicReductionFor() {
  function test_preduce_invoke_basic (line 192) | void test_preduce_invoke_basic(const Body& body, const Reduction& reduct...
  function test_vector_of_lists_rvalue_reduce_basic (line 233) | void test_vector_of_lists_rvalue_reduce_basic(const Runner& runner, Part...
  type ReduceRunner (line 287) | struct ReduceRunner {
  type DeterministicReduceRunner (line 294) | struct DeterministicReduceRunner {
  function test_vector_of_lists_rvalue_reduce (line 301) | void test_vector_of_lists_rvalue_reduce() {
  function test_vector_of_lists_rvalue_deterministic_reduce (line 319) | void test_vector_of_lists_rvalue_deterministic_reduce() {

FILE: third-party/tbb/test/conformance/conformance_parallel_scan.cpp
  class Body (line 35) | class Body {
    method Body (line 41) | Body( const std::vector<T>& z_, std::vector<T>& y_, T id ) : identity(...
    method T (line 42) | T get_sum() const { return sum; }
    method Body (line 54) | Body( Body& b, oneapi::tbb::split ): identity(b.identity), sum(b.ident...
    method reverse_join (line 55) | void reverse_join( Body& a ) { sum = Op()(a.sum, sum); }
    method assign (line 56) | void assign( Body& b ) { sum = b.sum; }
  class default_partitioner_tag (line 59) | class default_partitioner_tag{}
  type parallel_scan_wrapper (line 62) | struct parallel_scan_wrapper{
  type parallel_scan_wrapper<default_partitioner_tag> (line 70) | struct parallel_scan_wrapper<default_partitioner_tag>{
  function test_pscan_invoke (line 141) | void test_pscan_invoke(const std::vector<std::size_t>& desired_vector,

FILE: third-party/tbb/test/conformance/conformance_parallel_sort.cpp
  function get_random_vector (line 30) | std::vector<int> get_random_vector() {

FILE: third-party/tbb/test/conformance/conformance_sequencer_node.cpp
  function test_deduction_guides_common (line 32) | void test_deduction_guides_common(Body body) {
  function sequencer_body_f (line 49) | std::size_t sequencer_body_f(const int&) { return 1; }
  function test_deduction_guides (line 51) | void test_deduction_guides() {

FILE: third-party/tbb/test/conformance/conformance_task_arena.cpp
  class conformance_observer (line 80) | class conformance_observer: public oneapi::tbb::task_scheduler_observer {
    method conformance_observer (line 85) | conformance_observer( oneapi::tbb::task_arena &a ) : oneapi::tbb::task...
    method on_scheduler_entry (line 93) | void on_scheduler_entry(bool) override {
    method on_scheduler_exit (line 97) | void on_scheduler_exit(bool) override {
    method is_callbacks_called (line 101) | bool is_callbacks_called() {

FILE: third-party/tbb/test/conformance/conformance_task_group.cpp
  type accept_task_group_context (line 194) | namespace accept_task_group_context {
    type SelfRunner (line 196) | struct SelfRunner {
    function run_cancellation_use_case (line 207) | void run_cancellation_use_case(CancelF&& cancel, WaitF&& wait) {
    function test (line 250) | void test() {

FILE: third-party/tbb/test/conformance/conformance_tick_count.cpp
  function WaitForDuration (line 56) | static void WaitForDuration( double duration ) {
  function CheckNear (line 67) | void CheckNear( double x, double y ) {

FILE: third-party/tbb/test/tbb/test_arena_constraints.cpp
  function is_observer_created (line 35) | bool is_observer_created(const tbb::task_arena::constraints& c) {
  function recursive_arena_binding (line 44) | void recursive_arena_binding(constraints_container::iterator current_pos...
  function check_concurrency_level (line 181) | void check_concurrency_level(const tbb::task_arena::constraints& c) {

FILE: third-party/tbb/test/tbb/test_arena_priorities.cpp
  type HighPriorityArenasTakeExecutionPrecedence (line 42) | namespace HighPriorityArenasTakeExecutionPrecedence {
    type arena_info_keys (line 51) | enum arena_info_keys {
    function prepare_logging_data (line 55) | void prepare_logging_data(std::vector<tbb::task_arena::priority>& task...
    type initialization_methods (line 68) | enum initialization_methods {
    function submit_work (line 140) | void submit_work( std::vector<arena_info>& arenas, unsigned repeats, u...
    function wait_work_completion (line 164) | void wait_work_completion(
    function test (line 179) | void test() {

FILE: third-party/tbb/test/tbb/test_async_node.cpp
  class minimal_type (line 45) | class minimal_type {
    method minimal_type (line 52) | minimal_type() : value(-1) {}
    method minimal_type (line 53) | minimal_type(int v) : value(v) {}
    method minimal_type (line 54) | minimal_type(const minimal_type &m) : value(m.value) { }
    method minimal_type (line 55) | minimal_type &operator=(const minimal_type &m) { value = m.value; retu...
  type place_wrapper (line 59) | struct place_wrapper {
    method place_wrapper (line 64) | place_wrapper( int v = 0 ) : value(v), thread_id(std::this_thread::get...
    method place_wrapper (line 67) | place_wrapper(const place_wrapper<Q>& v)
  type wrapper_helper (line 83) | struct wrapper_helper {
    method check (line 84) | static void check(const T1 &, const T2 &) { }
    method copy_value (line 85) | static void copy_value(const T1 &in, T2 &out) { out = in; }
  type wrapper_helper< place_wrapper<T1>, place_wrapper<T2> > (line 89) | struct wrapper_helper< place_wrapper<T1>, place_wrapper<T2> > {
    method check (line 90) | static void check(const place_wrapper<T1> &a, const place_wrapper<T2> ...
    method copy_value (line 94) | static void copy_value(const place_wrapper<T1> &in, place_wrapper<T2> ...
  type counting_async_unlimited_body (line 109) | struct counting_async_unlimited_body {
    method counting_async_unlimited_body (line 111) | counting_async_unlimited_body(tbb::task_group_context& graph_tgc) : my...
  type counting_async_serial_body (line 131) | struct counting_async_serial_body : counting_async_unlimited_body {
    method counting_async_serial_body (line 135) | counting_async_serial_body(tbb::task_group_context& tgc)
  function test_reset (line 144) | void test_reset() {
  class async_activity_queue (line 284) | class async_activity_queue {
    method push (line 286) | void push( const T& item ) {
    method try_pop (line 291) | bool try_pop( T& item ) {
    method empty (line 300) | bool empty() {
  class async_activity (line 312) | class async_activity : utils::NoAssign {
    type work_type (line 319) | struct work_type {
    class ServiceThreadBody (line 324) | class ServiceThreadBody {
      method ServiceThreadBody (line 326) | ServiceThreadBody( async_activity* activity ) : my_activity( activit...
    method async_activity (line 332) | async_activity(int expected_items, bool deferred = false, int sleep_ti...
    method async_activity (line 342) | async_activity( const async_activity& )
    method submit (line 354) | void submit( const input_type &input, gateway_type& gateway ) {
    method process (line 359) | void process() {
    method stop (line 377) | void stop() {
    method activate (line 381) | void activate() {
    method should_reserve_each_time (line 385) | bool should_reserve_each_time() {
  type basic_test (line 406) | struct basic_test {
    method basic_test (line 412) | basic_test() {}
    method run (line 414) | static int run(int async_expected_items = UNKNOWN_NUMBER_OF_ITEMS) {
  function test_copy_ctor (line 466) | int test_copy_ctor() {
  type spin_test (line 509) | struct spin_test {
    class end_body_type (line 515) | class end_body_type {
      method end_body_type (line 520) | end_body_type(std::thread::id t, utils::SpinBarrier &b) : my_main_ti...
    method spin_test (line 531) | spin_test() {}
    method run (line 533) | static int run(int nthreads, int async_expected_items = UNKNOWN_NUMBER...
  function test_for_spin_avoidance (line 588) | void test_for_spin_avoidance() {
  function run_tests (line 598) | int run_tests() {
  class enqueueing_on_inner_level (line 608) | class enqueueing_on_inner_level {
    class body_graph_with_async (line 615) | class body_graph_with_async {
      method body_graph_with_async (line 617) | body_graph_with_async( utils::SpinBarrier& barrier, async_activity_t...
    method run (line 652) | static int run ()
  function run_test_enqueueing_on_inner_level (line 664) | int run_test_enqueueing_on_inner_level() {
  class AsyncActivity (line 673) | class AsyncActivity {
    type work_type (line 677) | struct work_type {
    method AsyncActivity (line 682) | AsyncActivity(size_t limit) : stop_limit(limit), c(0), thr([this]() {
    method submit (line 694) | void submit(int i, gateway_t* gateway) {
    method wait_for_all (line 700) | void wait_for_all() { thr.join(); }
    method end_of_work (line 703) | bool end_of_work() { return c >= stop_limit; }
    method do_work (line 705) | int do_work(int& i) { return i + i; }
  function test_follows (line 713) | void test_follows() {
  function test_precedes (line 751) | void test_precedes() {
  function test_follows_and_precedes_api (line 784) | void test_follows_and_precedes_api() {
  type InputObject (line 844) | struct InputObject {
    method InputObject (line 845) | InputObject() = default;
    method InputObject (line 846) | InputObject( const InputObject& ) = default;

FILE: third-party/tbb/test/tbb/test_blocked_range.cpp
  function test_blocked_range_constraint (line 91) | void test_blocked_range_constraint() {}
  function test_blocked_range2d_constraint (line 95) | void test_blocked_range2d_constraint() {}
  function test_blocked_range2d_col_invalid_constraint (line 99) | void test_blocked_range2d_col_invalid_constraint() {}
  function test_blocked_range2d_row_invalid_constraint (line 103) | void test_blocked_range2d_row_invalid_constraint() {}
  function test_blocked_range3d_constraint (line 107) | void test_blocked_range3d_constraint() {}
  function test_blocked_range3d_page_invalid_constraint (line 111) | void test_blocked_range3d_page_invalid_constraint() {}
  function test_blocked_range3d_row_invalid_constraint (line 115) | void test_blocked_range3d_row_invalid_constraint() {}
  function test_blocked_range3d_col_invalid_constraint (line 119) | void test_blocked_range3d_col_invalid_constraint() {}
  function test_deduction_guides (line 198) | void test_deduction_guides() {
  class fancy_value (line 306) | class fancy_value {
    method fancy_value (line 308) | fancy_value(std::size_t real_value) : my_real_value(real_value) {}
    method fancy_value (line 309) | fancy_value(const fancy_value&) = default;
    method fancy_value (line 311) | fancy_value& operator=(const fancy_value&) = default;
    method fancy_value (line 322) | fancy_value operator+(const fancy_value& lhs, std::size_t offset) {

FILE: third-party/tbb/test/tbb/test_broadcast_node.cpp
  type tbb (line 33) | namespace tbb {
  class int_convertable_type (line 41) | class int_convertable_type : private utils::NoAssign {
    method int_convertable_type (line 47) | int_convertable_type( int v ) : my_value(v) {}
  class counting_array_receiver (line 54) | class counting_array_receiver : public tbb::flow::receiver<T> {
    method counting_array_receiver (line 61) | counting_array_receiver(tbb::flow::graph& g) : my_graph(g) {
  function test_serial_broadcasts (line 88) | void test_serial_broadcasts() {
  class native_body (line 120) | class native_body : private utils::NoAssign {
    method native_body (line 126) | native_body( tbb::flow::broadcast_node<T> &b ) : my_b(b) {}
  function run_parallel_broadcasts (line 137) | void run_parallel_broadcasts(tbb::flow::graph& g, int p, tbb::flow::broa...
  function test_parallel_broadcasts (line 162) | void test_parallel_broadcasts(int p) {
  function test_resets (line 176) | void test_resets() {
  function test_follows_and_precedes_api (line 216) | void test_follows_and_precedes_api() {
  function test_deduction_guides (line 228) | void test_deduction_guides() {
  function test_try_put_and_wait_spawning_and_serial_receiver (line 257) | void test_try_put_and_wait_spawning_and_serial_receiver() {
  function test_try_put_and_wait_spawning_receivers (line 341) | void test_try_put_and_wait_spawning_receivers() {
  function test_try_put_and_wait (line 404) | void test_try_put_and_wait() {

FILE: third-party/tbb/test/tbb/test_buffer_node.cpp
  function spin_try_get (line 36) | void spin_try_get( tbb::flow::buffer_node<T> &b, T &value ) {
  function check_item (line 41) | void check_item( T* count_value, T &value ) {
  type parallel_puts (line 46) | struct parallel_puts : utils::NoAssign {
    method parallel_puts (line 50) | parallel_puts( tbb::flow::buffer_node<T> &b ) : my_b(b) {}
  type touches (line 61) | struct touches {
    method touches (line 66) | touches( int num_threads ) : my_num_threads(num_threads) {
    method check (line 82) | bool check( T v ) {
    method validate_touches (line 88) | bool validate_touches() {
  type parallel_gets (line 99) | struct parallel_gets : utils::NoAssign {
    method parallel_gets (line 104) | parallel_gets( tbb::flow::buffer_node<T> &b, touches<T> &t) : my_b(b),...
  type parallel_put_get (line 117) | struct parallel_put_get : utils::NoAssign {
    method parallel_put_get (line 122) | parallel_put_get( tbb::flow::buffer_node<T> &b, touches<T> &t ) : my_b...
  function test_reservation (line 149) | int test_reservation() {
  function test_parallel (line 199) | int test_parallel(int num_threads) {
  function test_serial (line 315) | int test_serial() {
  function test_follows_and_precedes_api (line 426) | void test_follows_and_precedes_api() {
  function test_deduction_guides (line 438) | void test_deduction_guides() {
  function test_buffer_node_try_put_and_wait (line 459) | void test_buffer_node_try_put_and_wait() {

FILE: third-party/tbb/test/tbb/test_collaborative_call_once.cpp
  type increment_functor (line 43) | struct increment_functor {
  type sum_functor (line 51) | struct sum_functor {
  type move_only_type (line 66) | struct move_only_type {
    method move_only_type (line 68) | move_only_type(move_only_type && other): my_pointer(other.my_pointer){...
    method move_only_type (line 69) | explicit move_only_type(const int* value): my_pointer(value) {}
  class call_once_exception (line 73) | class call_once_exception : public std::exception {}
  function call_once_in_for_loop (line 76) | void call_once_in_for_loop(std::size_t N, Fn&& body, Args&&... args) {
  function call_once_in_parallel_for (line 84) | void call_once_in_parallel_for(std::size_t N, Fn&& body, Args&&... args) {
  function call_once_threads (line 103) | void call_once_threads(std::size_t N, Fn&& body, Args&&... args) {
  function collaborative_recursive_fib (line 388) | std::uint64_t collaborative_recursive_fib(int n, FibBuffer& buffer) {
  function collaborative_recursive_fib (line 401) | std::uint64_t collaborative_recursive_fib(int n) {

FILE: third-party/tbb/test/tbb/test_composite_node.cpp
  type passthru_body (line 38) | struct passthru_body {
  class my_input_body (line 44) | class my_input_body{
    method my_input_body (line 49) | my_input_body(int f, int s) : start(1), finish(f), step(s) {}
  type m_fxn_body (line 64) | struct m_fxn_body{
  type ct_body (line 68) | struct ct_body {
    method ct_body (line 69) | ct_body(){}
  type seq_body (line 73) | struct seq_body {
  type compare (line 78) | struct compare {
    method compare_refs (line 79) | static void compare_refs(T1 tuple1, T2 tuple2) {
  type compare<1, T1, T2> (line 86) | struct compare<1, T1, T2> {
    method compare_refs (line 87) | static void compare_refs(T1 tuple1, T2 tuple2) {
  type tiny_node (line 92) | struct tiny_node : public tbb::flow::composite_node< std::tuple< int >, ...
    method tiny_node (line 98) | tiny_node(tbb::flow::graph &g, bool hidden = false) : base_type(g), f1...
  function test_tiny (line 113) | int test_tiny(bool hidden = false) {
  class adder_node (line 166) | class adder_node : public tbb::flow::composite_node< std::tuple< int, in...
    type f_body (line 173) | struct f_body {
    method adder_node (line 180) | adder_node(tbb::flow::graph &g, bool hidden = false) : base_type(g), j...
  type square_body (line 193) | struct square_body { int operator()(int v) { return v*v; } }
  type cube_body (line 194) | struct cube_body { int operator()(int v) { return v*v*v; } }
  function adder_sum (line 195) | int adder_sum(int i) {
  function test_adder (line 198) | int test_adder(bool hidden = false) {
  function test_nested_adder (line 296) | int test_nested_adder(bool hidden=false) {
  class prefix_node (line 343) | class prefix_node : public tbb::flow::composite_node< std::tuple< T, T, ...
    type f_body (line 352) | struct f_body {
      method my_tuple_t (line 353) | my_tuple_t operator()( const my_tuple_t &t ) {
    method prefix_node (line 363) | prefix_node(tbb::flow::graph &g, bool hidden = false ) : base_type(g),...
  function test_prefix (line 381) | int test_prefix(bool hidden = false) {
  type input_only_output_only_seq (line 425) | struct input_only_output_only_seq {
  function input_only_output_only_composite (line 432) | void input_only_output_only_composite(bool hidden) {

FILE: third-party/tbb/test/tbb/test_concurrent_hash_map.cpp
  function TestRangeBasedFor (line 47) | void TestRangeBasedFor(){
  type do_default_construction_test (line 64) | struct do_default_construction_test {
  type do_default_construction_test<false> (line 68) | struct do_default_construction_test<false> {
  class test_insert_by_key (line 73) | class test_insert_by_key {
    method test_insert_by_key (line 78) | test_insert_by_key( Table &c, const value_type &value ) : my_c(c), my_...
  class test_range (line 96) | class test_range {
    method test_range (line 102) | test_range( Table &c, const std::list<value_type> &lst, std::vector<de...
    method do_test_range (line 109) | void do_test_range( Iterator i, Iterator j ) const {
  class check_value (line 122) | class check_value {
    method check_value (line 128) | check_value( Table &c ) : my_c(c) {}
  type CompareTables (line 178) | struct CompareTables {
    method IsEqual (line 180) | static bool IsEqual( const T& t1, const T& t2 ) {
  type CompareTables< std::pair<const std::weak_ptr<U>, std::weak_ptr<U> > > (line 186) | struct CompareTables< std::pair<const std::weak_ptr<U>, std::weak_ptr<U>...
    method IsEqual (line 188) | static bool IsEqual( const T&, const T& ) {
  function Examine (line 195) | void Examine( Table c, const std::list<typename Table::value_type> &lst) {
  type debug_hash_compare (line 253) | struct debug_hash_compare : public tbb::detail::d1::tbb_hash_compare<T> {}
  function TypeTester (line 256) | void TypeTester( const std::list<Value> &lst ) {
  function TestSpecificTypes (line 325) | void TestSpecificTypes() {
  type custom_hash_compare (line 377) | struct custom_hash_compare {
    method hash (line 379) | size_t hash(const AllocatorAwareData<Allocator>& key) const {
    method equal (line 384) | bool equal(const AllocatorAwareData<Allocator>& key1, const AllocatorA...
  function TestScopedAllocator (line 392) | void TestScopedAllocator() {
  function TestInternalFastFind (line 439) | void TestInternalFastFind() {
  type default_container_traits (line 472) | struct default_container_traits {
    method container_type (line 474) | static container_type& construct_container(typename std::aligned_stora...
    method container_type (line 481) | static container_type& construct_container(typename std::aligned_stora...
  type hash_map_traits (line 488) | struct hash_map_traits : default_container_traits {
    type hash_compare (line 492) | struct hash_compare {
      method equal (line 493) | bool equal( const T& lhs, const T& rhs ) const {
      method hash (line 496) | size_t hash( const T& k ) const {
    type apply (line 509) | struct apply {
    method equal (line 515) | static bool equal(hash_map_type const& c, iterator begin, iterator end){
  class MinimalisticMutex (line 530) | class MinimalisticMutex {
    class scoped_lock (line 536) | class scoped_lock {
      method scoped_lock (line 538) | constexpr scoped_lock() noexcept : my_mutex_ptr(nullptr) {}
      method scoped_lock (line 540) | scoped_lock( MinimalisticMutex& m, bool = true ) : my_mutex_ptr(&m) {
      method scoped_lock (line 544) | scoped_lock( const scoped_lock& ) = delete;
      method scoped_lock (line 545) | scoped_lock& operator=( const scoped_lock& ) = delete;
      method acquire (line 551) | void acquire( MinimalisticMutex& m, bool = true ) {
      method try_acquire (line 557) | bool try_acquire( MinimalisticMutex& m, bool = true ) {
      method release (line 565) | void release() {
      method upgrade_to_writer (line 571) | bool upgrade_to_writer() const {
      method downgrade_to_reader (line 577) | bool downgrade_to_reader() const {
      method is_writer (line 583) | bool is_writer() const {
  function test_with_minimalistic_mutex (line 596) | void test_with_minimalistic_mutex() {
  function test_mutex_customization (line 679) | void test_mutex_customization() {
  type SimpleTransparentHashCompare (line 684) | struct SimpleTransparentHashCompare {
    method hash (line 688) | std::size_t hash(const T&) const { return 0; }
    method equal (line 691) | bool equal(const T& key1, const U& key2) const { return key1 == key2; }
  type IsWriterAccessor (line 695) | struct IsWriterAccessor : public Accessor {
  function test_chmap_access_mode (line 700) | void test_chmap_access_mode(bool expect_write) {
  function test_chmap_hash_compare_constraints (line 855) | void test_chmap_hash_compare_constraints() {}
  function test_chmap_mutex_constraints (line 876) | void test_chmap_mutex_constraints() {}

FILE: third-party/tbb/test/tbb/test_concurrent_map.cpp
  type AllowMultimapping<tbb::concurrent_multimap<Args...>> (line 26) | struct AllowMultimapping<tbb::concurrent_multimap<Args...>> : std::true_...
  type SpecialTests<map_type> (line 45) | struct SpecialTests<map_type> {
    method Test (line 46) | static void Test() {
  type SpecialTests<multimap_type> (line 52) | struct SpecialTests<multimap_type> {
    method Test (line 53) | static void Test() {
  type COMapTraits (line 58) | struct COMapTraits : OrderedMoveTraitsBase {
  type COMultimapTraits (line 68) | struct COMultimapTraits : OrderedMoveTraitsBase {
  type OrderedMapTypesTester (line 78) | struct OrderedMapTypesTester {
    method check (line 80) | void check( const std::list<ValueType>& lst ) {
  function test_specific_types (line 89) | void test_specific_types() {
  function test_cycles_absense (line 102) | void test_cycles_absense() {

FILE: third-party/tbb/test/tbb/test_concurrent_monitor.cpp
  type notification_types (line 42) | enum class notification_types {

FILE: third-party/tbb/test/tbb/test_concurrent_priority_queue.cpp
  function test_cpq_with_smart_pointers (line 27) | void test_cpq_with_smart_pointers() {
  type MyDataType (line 50) | struct MyDataType {
    method MyDataType (line 54) | MyDataType() = default;
    method MyDataType (line 55) | MyDataType( int val ) : priority(std::size_t(val)) {}
    method MyDataType (line 57) | const MyDataType operator+( const MyDataType& other ) const {
  type MyLess (line 69) | struct MyLess {
  function test_concurrent (line 75) | void test_concurrent( std::size_t n ) {
  function test_multithreading (line 80) | void test_multithreading() {
  type MyThrowingType (line 86) | struct MyThrowingType : public MyDataType {
    method MyThrowingType (line 88) | MyThrowingType() = default;
    method MyThrowingType (line 89) | MyThrowingType( const MyThrowingType& src ) : MyDataType(src) {
    method MyThrowingType (line 95) | MyThrowingType& operator=( const MyThrowingType& other ) {
  function test_exceptions (line 106) | void test_exceptions() {
  function test_scoped_allocator (line 189) | void test_scoped_allocator() {

FILE: third-party/tbb/test/tbb/test_concurrent_queue.cpp
  type TestQueueElements (line 31) | struct TestQueueElements {
    method TestQueueElements (line 34) | TestQueueElements( CQ& q, std::size_t n ) : queue(q), nthread(n) {}
  function TestPrimitiveTypes (line 52) | void TestPrimitiveTypes(std::size_t nthread, T exemplar) {
  function TestQueueWorksWithPrimitiveTypes (line 60) | void TestQueueWorksWithPrimitiveTypes() {
  function TestVectorTypes (line 75) | void TestVectorTypes() {
  function TestQueueWorksWithSSE (line 105) | void TestQueueWorksWithSSE() {
  type throw_element (line 122) | struct throw_element {
    method throw_element (line 123) | throw_element() = default;
    method throw_element (line 124) | throw_element(const throw_element&) {
    method throw_element (line 130) | throw_element& operator= (const throw_element&) = default;
  function CopyWithThrowElement (line 134) | void CopyWithThrowElement() {
  type TrackableItem (line 204) | struct TrackableItem {
    method TrackableItem (line 210) | TrackableItem() {
  function fill_and_catch (line 227) | void fill_and_catch(Container& q, std::size_t elements_count) {
  function test_tracking_dtors_on_clear (line 253) | void test_tracking_dtors_on_clear() {

FILE: third-party/tbb/test/tbb/test_concurrent_queue_whitebox.cpp
  class FloggerBody (line 42) | class FloggerBody {
    method FloggerBody (line 44) | FloggerBody& operator=( const FloggerBody& ) = delete;
    method FloggerBody (line 46) | FloggerBody( Q& queue, std::size_t el_num )
  function test_flogger_help (line 65) | void test_flogger_help( Q& q, std::size_t items_per_page ) {

FILE: third-party/tbb/test/tbb/test_concurrent_set.cpp
  type AllowMultimapping<tbb::concurrent_multiset<Args...>> (line 27) | struct AllowMultimapping<tbb::concurrent_multiset<Args...>> : std::true_...
  type COSetTraits (line 43) | struct COSetTraits : OrderedMoveTraitsBase {
  type COMultisetTraits (line 53) | struct COMultisetTraits : OrderedMoveTraitsBase {
  type OrderedSetTypesTester (line 63) | struct OrderedSetTypesTester {
    method check (line 65) | void check( const std::list<ValueType>& lst ) {
  function test_specific_types (line 71) | void test_specific_types() {
  function test_cycles_absense (line 84) | void test_cycles_absense() {

FILE: third-party/tbb/test/tbb/test_concurrent_unordered_map.cpp
  type AllowMultimapping<tbb::concurrent_unordered_multimap<Args...>> (line 29) | struct AllowMultimapping<tbb::concurrent_unordered_multimap<Args...>> : ...
  type CumapTraits (line 48) | struct CumapTraits : UnorderedMoveTraitsBase {
  type CumultimapTraits (line 58) | struct CumultimapTraits : UnorderedMoveTraitsBase {
  type SpecialTests<map_type> (line 69) | struct SpecialTests<map_type> {
    method Test (line 70) | static void Test() {
  type SpecialTests<multimap_type> (line 76) | struct SpecialTests<multimap_type> {
    method Test (line 77) | static void Test() {
  type UnorderedMapTypesTester (line 82) | struct UnorderedMapTypesTester {
    method check (line 87) | void check( const std::list<ValueType>& lst ) {
  function test_specific_types (line 96) | void test_specific_types() {

FILE: third-party/tbb/test/tbb/test_concurrent_unordered_set.cpp
  type AllowMultimapping<tbb::concurrent_unordered_multiset<Args...>> (line 29) | struct AllowMultimapping<tbb::concurrent_unordered_multiset<Args...>> : ...
  type CusetTraits (line 49) | struct CusetTraits : UnorderedMoveTraitsBase {
  type CumultisetTraits (line 59) | struct CumultisetTraits : UnorderedMoveTraitsBase {
  type UnorderedSetTypesTester (line 69) | struct UnorderedSetTypesTester {
    method check (line 71) | void check( const std::list<ValueType>& lst ) {
  function test_specific_types (line 77) | void test_specific_types() {

FILE: third-party/tbb/test/tbb/test_concurrent_vector.cpp
  function TestSort (line 41) | void TestSort() {
  function TestRangeBasedFor (line 54) | void TestRangeBasedFor(){
  type default_container_traits (line 68) | struct default_container_traits {
    method container_type (line 70) | static container_type& construct_container(typename std::aligned_stora...
    method container_type (line 77) | static container_type& construct_container(typename std::aligned_stora...
  type c_vector_type (line 84) | struct c_vector_type : default_container_traits {
    type apply (line 93) | struct apply{
    method equal (line 100) | static bool equal(tbb::concurrent_vector<element_type, allocator_type ...
  function TestSerialGrowByWithMoveIterators (line 106) | void TestSerialGrowByWithMoveIterators(){
  function TestVectorTypes (line 121) | void TestVectorTypes() {
  class FindPrimes (line 138) | class FindPrimes {
    method is_prime (line 139) | bool is_prime( std::size_t val ) const {
  function TimeFindPrimes (line 158) | double TimeFindPrimes( std::size_t nthread ) {
  function TestFindPrimes (line 169) | void TestFindPrimes() {
  class test_grow_by_and_resize (line 192) | class test_grow_by_and_resize {
    method test_grow_by_and_resize (line 195) | test_grow_by_and_resize( tbb::concurrent_vector<Type, Allocator> &c ) ...
  function test_scoped_allocator (line 205) | void test_scoped_allocator() {
  type do_default_construction_test (line 258) | struct do_default_construction_test {
  type do_default_construction_test<false> (line 261) | struct do_default_construction_test<false> {
  function CompareVectors (line 266) | void CompareVectors( const tbb::concurrent_vector<Type, Allocator> &c1, ...
  function CompareVectors (line 272) | void CompareVectors( const tbb::concurrent_vector<std::weak_ptr<Type>, A...
  function Examine (line 277) | void Examine( tbb::concurrent_vector<Type, Allocator> c, const std::vect...
  class test_default_construction (line 311) | class test_default_construction {
    method test_default_construction (line 314) | test_default_construction( const std::vector<Type> &vec ) : my_vec(vec...
  function TypeTester (line 327) | void TypeTester( const std::vector<Type> &vec ) {
  function TestTypes (line 357) | void TestTypes() {
  function test_grow_by_empty_range (line 383) | void test_grow_by_empty_range( Vector &v, typename Vector::value_type* r...
  function TestSerialGrowByRange (line 389) | void TestSerialGrowByRange( bool fragmented_vector ) {
  function TestConcurrentOperationsWithUnSafeOperations (line 402) | void TestConcurrentOperationsWithUnSafeOperations(std::size_t threads_nu...
  function reduce_vector (line 524) | int reduce_vector(RangeType test_range) {

FILE: third-party/tbb/test/tbb/test_continue_node.cpp
  type fake_continue_sender (line 37) | struct fake_continue_sender : public tbb::flow::sender<tbb::flow::contin...
    method register_successor (line 41) | bool register_successor( successor_type& ) override { return false; }
    method remove_successor (line 42) | bool remove_successor( successor_type& )   override { return false; }
  type parallel_puts (line 46) | struct parallel_puts {
    method parallel_puts (line 50) | parallel_puts( tbb::flow::receiver< InputType > &exe_node ) : my_exe_n...
    method parallel_puts (line 51) | parallel_puts& operator=(const parallel_puts&) = delete;
  function run_continue_nodes (line 63) | void run_continue_nodes( int p, tbb::flow::graph& g, tbb::flow::continue...
  function continue_nodes (line 99) | void continue_nodes( Body body ) {
  type inc_functor (line 114) | struct inc_functor {
    method inc_functor (line 117) | inc_functor( ) { local_execute_count = 0; }
    method inc_functor (line 118) | inc_functor( const inc_functor &f ) { local_execute_count = size_t(f.l...
    method OutputType (line 121) | OutputType operator()( tbb::flow::continue_msg ) {
  function continue_nodes_with_copy (line 130) | void continue_nodes_with_copy( ) {
  function run_continue_nodes (line 184) | void run_continue_nodes() {
  function test_concurrency (line 193) | void test_concurrency(int num_threads) {
  type add_to_counter (line 211) | struct add_to_counter {
    method add_to_counter (line 213) | add_to_counter(int& var):counter(&var){}
  function test_two_graphs (line 217) | void test_two_graphs(){
  type lightweight_policy_body (line 253) | struct lightweight_policy_body {
    method lightweight_policy_body (line 257) | lightweight_policy_body( std::atomic<size_t>& count )
    method lightweight_policy_body (line 263) | lightweight_policy_body( const lightweight_policy_body& ) = default;
    method lightweight_policy_body (line 264) | lightweight_policy_body& operator=( const lightweight_policy_body& ) =...
  function test_lightweight_policy (line 273) | void test_lightweight_policy() {
  function test_follows_and_precedes_api (line 298) | void test_follows_and_precedes_api() {
  type passing_body (line 318) | struct passing_body {
    method T (line 319) | T operator()(const T& val) {
  function test_successor_cache_specialization (line 330) | void test_successor_cache_specialization() {
  function test_try_put_and_wait_default (line 358) | void test_try_put_and_wait_default() {
  function test_try_put_and_wait_lightweight (line 400) | void test_try_put_and_wait_lightweight() {
  function test_metainfo_buffering (line 472) | void test_metainfo_buffering() {
  function test_try_put_and_wait (line 520) | void test_try_put_and_wait() {

FILE: third-party/tbb/test/tbb/test_dynamic_link.cpp
  type FOO_TYPE (line 26) | enum FOO_TYPE {
  function TEST_EXPORT (line 38) | TEST_EXPORT FOO_TYPE foo1() { return FOO_IMPLEMENTATION; }
  function TEST_EXPORT (line 39) | TEST_EXPORT FOO_TYPE foo2() { return FOO_IMPLEMENTATION; }
  function FOO_TYPE (line 41) | FOO_TYPE dummy_foo1() { return FOO_DUMMY; }
  function FOO_TYPE (line 42) | FOO_TYPE dummy_foo2() { return FOO_DUMMY; }
  function test_dynamic_link (line 68) | void test_dynamic_link(const char* lib_name) {

FILE: third-party/tbb/test/tbb/test_eh_algorithms.cpp
  type context_specific_counter (line 46) | struct context_specific_counter {
    method increment (line 49) | void increment() {
    method reset (line 55) | void reset() {
    method validate (line 59) | void validate(unsigned expected_count, const char* msg) {
  function ResetGlobals (line 103) | inline void ResetGlobals (  bool throwException = true, bool flog = fals...
  function CountSubranges (line 118) | inline intptr_t CountSubranges(range_type r) {
  function NumSubranges (line 124) | inline intptr_t NumSubranges ( intptr_t length, intptr_t grain ) {
  function TestNumSubrangesCalculation (line 129) | intptr_t TestNumSubrangesCalculation ( intptr_t length, intptr_t grain, ...
  class NoThrowParForBody (line 140) | class NoThrowParForBody {
  function Test0 (line 152) | void Test0 () {
  class SimpleParReduceBody (line 165) | class SimpleParReduceBody {
    method SimpleParReduceBody (line 169) | SimpleParReduceBody(const SimpleParReduceBody&) = default;
    method SimpleParReduceBody (line 170) | SimpleParReduceBody() = default;
    method SimpleParReduceBody (line 173) | SimpleParReduceBody( SimpleParReduceBody& left, tbb::split ) : m_Body(...
    method join (line 174) | void join( SimpleParReduceBody& /*right*/ ) {}
  function TestParallelLoopAux (line 180) | void TestParallelLoopAux() {
  function TestParallelLoop (line 223) | void TestParallelLoop() {
  class SimpleParForBody (line 235) | class SimpleParForBody {
    method SimpleParForBody (line 238) | SimpleParForBody(const SimpleParForBody&) = default;
    method SimpleParForBody (line 239) | SimpleParForBody() = default;
  function Test1 (line 253) | void Test1() {
  class OuterParForBody (line 258) | class OuterParForBody {
    method OuterParForBody (line 261) | OuterParForBody(const OuterParForBody&) = default;
    method OuterParForBody (line 262) | OuterParForBody() = default;
  function Test2 (line 275) | void Test2 () {
  class OuterParForBodyWithIsolatedCtx (line 279) | class OuterParForBodyWithIsolatedCtx {
  function Test3 (line 294) | void Test3 () {
  class OuterParForExceptionSafeBody (line 335) | class OuterParForExceptionSafeBody {
  function Test4 (line 350) | void Test4 () {
  class ParForBodyToCancel (line 491) | class ParForBodyToCancel {
  class ParForLauncher (line 500) | class ParForLauncher {
    method ParForLauncher (line 506) | ParForLauncher ( tbb::task_group_context& ctx ) : my_ctx(ctx) {}
  function TestCancelation1 (line 510) | void TestCancelation1 () {
  class Cancellator2 (line 515) | class Cancellator2  {
    method Cancellator2 (line 526) | Cancellator2 ( tbb::task_group_context& ctx, intptr_t ) : m_GroupToCan...
  class ParForBodyToCancel2 (line 529) | class ParForBodyToCancel2 {
  function TestCancelation2 (line 542) | void TestCancelation2 () {
  class Worker (line 554) | class Worker {
    method Validate (line 560) | int Validate (int start_level) {
  class RecursiveParReduceBodyWithSharedWorker (line 568) | class RecursiveParReduceBodyWithSharedWorker {
    method RecursiveParReduceBodyWithSharedWorker (line 573) | RecursiveParReduceBodyWithSharedWorker ( RecursiveParReduceBodyWithSha...
    method RecursiveParReduceBodyWithSharedWorker (line 578) | RecursiveParReduceBodyWithSharedWorker ( Worker *w, int outer )
    method join (line 592) | void join (const RecursiveParReduceBodyWithSharedWorker & x) {
    method result (line 595) | int result () { return m_Result; }
  function TestCancelation3 (line 610) | void TestCancelation3 () {
  type StatsCounters (line 617) | struct StatsCounters {
    method StatsCounters (line 620) | StatsCounters() {
  class ParReduceBody (line 626) | class ParReduceBody {
    method ParReduceBody (line 633) | ParReduceBody( StatsCounters& s_, tbb::task_group_context& context, bo...
    method ParReduceBody (line 638) | ParReduceBody( const ParReduceBody& lhs ) : tgc(lhs.tgc) {
    method ParReduceBody (line 643) | ParReduceBody( ParReduceBody& lhs, tbb::split ) : tgc(lhs.tgc) {
    method join (line 660) | void join( ParReduceBody& /*rhs*/ ) {}
  function TestCancelation4 (line 663) | void TestCancelation4() {
  function get_iter_range_size (line 770) | std::size_t get_iter_range_size() {
  type adaptive_range (line 776) | struct adaptive_range {
    method adaptive_range (line 779) | adaptive_range(std::size_t size) : my_array(size + 1) {}
    method iterator (line 782) | iterator begin() const {
    method iterator (line 785) | iterator begin() {
    method iterator (line 788) | iterator end() const {
    method iterator (line 791) | iterator end() {
  function Feed (line 796) | void Feed ( tbb::feeder<size_t> &feeder, size_t val ) {
  class SimpleParForEachBody (line 814) | class SimpleParForEachBody {
  class SimpleParForEachBodyWithFeeder (line 831) | class SimpleParForEachBodyWithFeeder : SimpleParForEachBody {
  function Test1_parallel_for_each (line 841) | void Test1_parallel_for_each () {
  class OuterParForEachBody (line 856) | class OuterParForEachBody {
  class OuterParForEachBodyWithFeeder (line 866) | class OuterParForEachBodyWithFeeder : OuterParForEachBody<Iterator> {
  function Test2_parallel_for_each (line 880) | void Test2_parallel_for_each () {
  class OuterParForEachBodyWithIsolatedCtx (line 894) | class OuterParForEachBodyWithIsolatedCtx {
  class OuterParForEachBodyWithIsolatedCtxWithFeeder (line 905) | class OuterParForEachBodyWithIsolatedCtxWithFeeder : OuterParForEachBody...
  function Test3_parallel_for_each (line 920) | void Test3_parallel_for_each () {
  class OuterParForEachWithEhBody (line 944) | class OuterParForEachWithEhBody {
  class OuterParForEachWithEhBodyWithFeeder (line 957) | class OuterParForEachWithEhBodyWithFeeder : OuterParForEachWithEhBody<It...
    method OuterParForEachWithEhBodyWithFeeder (line 960) | OuterParForEachWithEhBodyWithFeeder(const OuterParForEachWithEhBodyWit...
    method OuterParForEachWithEhBodyWithFeeder (line 961) | OuterParForEachWithEhBodyWithFeeder() = default;
  function Test4_parallel_for_each (line 973) | void Test4_parallel_for_each () {
  class ParForEachBodyWithThrowingFeederTasks (line 1005) | class ParForEachBodyWithThrowingFeederTasks {
  function Test5_parallel_for_each (line 1021) | void Test5_parallel_for_each () {
  class ParForEachBodyToCancel (line 1152) | class ParForEachBodyToCancel {
  class ParForEachBodyToCancelWithFeeder (line 1160) | class ParForEachBodyToCancelWithFeeder : ParForEachBodyToCancel {
  class ParForEachWorker (line 1169) | class ParForEachWorker {
    method ParForEachWorker (line 1177) | ParForEachWorker ( tbb::task_group_context& ctx ) : my_ctx(ctx) {}
  function TestCancelation1_parallel_for_each (line 1182) | void TestCancelation1_parallel_for_each () {
  class ParForEachBodyToCancel2 (line 1200) | class ParForEachBodyToCancel2 {
  class ParForEachBodyToCancel2WithFeeder (line 1211) | class ParForEachBodyToCancel2WithFeeder : ParForEachBodyToCancel2 {
  function TestCancelation2_parallel_for_each (line 1222) | void TestCancelation2_parallel_for_each () {
  class InputFilter (line 1277) | class InputFilter {
    method InputFilter (line 1281) | InputFilter() : m_Buffer(get_iter_range_size()) {
    method InputFilter (line 1286) | InputFilter(const InputFilter& other) : m_Item(other.m_Item.load()), m...
  class SimpleFilter (line 1314) | class SimpleFilter {
    method SimpleFilter (line 1318) | SimpleFilter (bool canThrow, bool serial ) : m_canThrow(canThrow), m_s...
  type FilterSet (line 1336) | struct FilterSet {
    method FilterSet (line 1340) | FilterSet( tbb::filter_mode m1, tbb::filter_mode m2, bool t1, bool t2 )
  class CustomPipeline (line 1348) | class CustomPipeline {
    method CustomPipeline (line 1354) | CustomPipeline( const FilterSet& filters )
    method run (line 1360) | void run () {
    method run (line 1368) | void run ( tbb::task_group_context& ctx ) {
  function Test1_pipeline (line 1382) | void Test1_pipeline ( const FilterSet& filters ) {
  class OuterFilter (line 1409) | class OuterFilter {
    method OuterFilter (line 1411) | OuterFilter ( bool, bool ) {}
  function Test2_pipeline (line 1426) | void Test2_pipeline ( const FilterSet& filters ) {
  class OuterFilterWithIsolatedCtx (line 1441) | class OuterFilterWithIsolatedCtx {
    method OuterFilterWithIsolatedCtx (line 1443) | OuterFilterWithIsolatedCtx( bool , bool ) {}
  function Test3_pipeline (line 1461) | void Test3_pipeline ( const FilterSet& filters ) {
  class OuterFilterWithEhBody (line 1515) | class OuterFilterWithEhBody  {
    method OuterFilterWithEhBody (line 1517) | OuterFilterWithEhBody( bool, bool ){}
  function Test4_pipeline (line 1534) | void Test4_pipeline ( const FilterSet& filters ) {
  function TestWithDifferentFiltersAndConcurrency (line 1578) | void TestWithDifferentFiltersAndConcurrency() {
  class FilterToCancel (line 1647) | class FilterToCancel  {
    method FilterToCancel (line 1649) | FilterToCancel() {}
  class PipelineLauncher (line 1658) | class PipelineLauncher {
    method PipelineLauncher (line 1661) | PipelineLauncher ( tbb::task_group_context& ctx ) : my_ctx(ctx) {}
  function TestCancelation1_pipeline (line 1677) | void TestCancelation1_pipeline () {
  class FilterToCancel2 (line 1688) | class FilterToCancel2  {
    method FilterToCancel2 (line 1690) | FilterToCancel2() {}
  function TestCancelation2_pipeline (line 1704) | void TestCancelation2_pipeline () {

FILE: third-party/tbb/test/tbb/test_eh_flow_graph.cpp
  type TestNodeTypeEnum (line 65) | enum TestNodeTypeEnum { nonThrowing, isThrowing }
  type TestNodeTypeName (line 71) | struct TestNodeTypeName
  type TestNodeTypeName<nonThrowing> (line 72) | struct TestNodeTypeName<nonThrowing> { static const char *name() { retur...
  type TestNodeTypeName<isThrowing> (line 73) | struct TestNodeTypeName<isThrowing> { static const char *name() { return...
  type concurrencyName (line 75) | struct concurrencyName
  type concurrencyName<serial_type> (line 76) | struct concurrencyName<serial_type>{ static const char *name() { return ...
  type concurrencyName<unlimited_type> (line 77) | struct concurrencyName<unlimited_type>{ static const char *name() { retu...
  type concurrencyName<limited_type> (line 78) | struct concurrencyName<limited_type>{ static const char *name() { return...
  class WaitThrow (line 87) | class WaitThrow
  class WaitThrow<serial_type,nonThrowing> (line 90) | class WaitThrow<serial_type,nonThrowing> {
    method WaitAndThrow (line 92) | void WaitAndThrow(int cnt, const char * /*name*/) {
  class WaitThrow<serial_type,isThrowing> (line 101) | class WaitThrow<serial_type,isThrowing> {
    method WaitAndThrow (line 103) | void WaitAndThrow(int cnt, const char * /*name*/) {
  class WaitThrow<limited_type,nonThrowing> (line 119) | class WaitThrow<limited_type,nonThrowing> {
    method WaitAndThrow (line 121) | void WaitAndThrow(int cnt, const char * /*name*/) {
  class WaitThrow<limited_type,isThrowing> (line 131) | class WaitThrow<limited_type,isThrowing> {
    method WaitAndThrow (line 133) | void WaitAndThrow(int cnt, const char * /*name*/) {
  class WaitThrow<unlimited_type,nonThrowing> (line 144) | class WaitThrow<unlimited_type,nonThrowing> {
    method WaitAndThrow (line 146) | void WaitAndThrow(int /*cnt*/, const char * /*name*/) {
  class WaitThrow<unlimited_type,isThrowing> (line 153) | class WaitThrow<unlimited_type,isThrowing> {
    method WaitAndThrow (line 155) | void WaitAndThrow(int /*cnt*/, const char * /*name*/) {
  function ResetGlobals (line 162) | void
  class test_input_body (line 171) | class test_input_body : WaitThrow<serial_type, TType> {
    method test_input_body (line 176) | test_input_body(std::atomic<int> &my_cnt, int multiplier = 1) : my_cur...
    method OutputType (line 180) | OutputType operator()(tbb::flow_control& fc) {
    method count_value (line 199) | int count_value() { return (int)*my_current_val; }
  class test_input_body<tbb::flow::continue_msg, TType> (line 203) | class test_input_body<tbb::flow::continue_msg, TType> : WaitThrow<serial...
    method test_input_body (line 207) | test_input_body(std::atomic<int> &my_cnt) : my_current_val(&my_cnt) { }
    method count_value (line 221) | int count_value() { return (int)*my_current_val; }
  class absorber_body (line 226) | class absorber_body : WaitThrow<Conc,T> {
    method absorber_body (line 230) | absorber_body(std::atomic<int> &my_cnt) : my_count(&my_cnt) { }
    method OutputType (line 231) | OutputType operator()(const InputType &/*p_in*/) {
    method count_value (line 237) | int count_value() { return *my_count; }
  type IssueOutput (line 244) | struct IssueOutput {
    method issue_tuple_element (line 247) | static void issue_tuple_element( PortsType &my_ports) {
  type IssueOutput<1,PortsType> (line 254) | struct IssueOutput<1,PortsType> {
    method issue_tuple_element (line 257) | static void issue_tuple_element( PortsType &my_ports) {
  class multifunction_node_body (line 263) | class multifunction_node_body : WaitThrow<Conc,T> {
    method multifunction_node_body (line 270) | multifunction_node_body(std::atomic<int> &my_cnt) : my_count(&my_cnt) { }
    method count_value (line 279) | int count_value() { return *my_count; }
  type sequencer_body (line 284) | struct sequencer_body {
  type less_body (line 293) | struct less_body {
  class tag_func (line 301) | class tag_func {
    method tag_func (line 304) | tag_func(TT multiplier) : my_mult(multiplier) { }
  class tuple_test_input_body (line 314) | class tuple_test_input_body : WaitThrow<serial_type, TType> {
    method tuple_test_input_body (line 320) | tuple_test_input_body(std::atomic<int> &my_cnt) : my_current_val(&my_c...
    method OutputTuple (line 322) | OutputTuple operator()(tbb::flow_control& fc) {
    method count_value (line 334) | int count_value() { return (int)*my_current_val; }
  function run_one_input_node_test (line 349) | void run_one_input_node_test(bool throwException, bool flog) {
  function run_input_node_test (line 417) | void run_input_node_test() {
  function test_input_node (line 423) | void test_input_node() {
  type NodeFetchType (line 444) | enum NodeFetchType { func_node_type, multifunc_node_type }
  type AttachPoint (line 447) | struct AttachPoint
  type AttachPoint<NodeType,ItemType,indx,multifunc_node_type> (line 450) | struct AttachPoint<NodeType,ItemType,indx,multifunc_node_type> {
  type AttachPoint<NodeType,ItemType,indx,func_node_type> (line 457) | struct AttachPoint<NodeType,ItemType,indx,func_node_type> {
  function run_one_functype_node_test (line 481) | void
  function run_function_node_test (line 590) | void run_function_node_test() {
  function test_function_node (line 625) | void test_function_node() {
  function run_multifunction_node_test (line 694) | void run_multifunction_node_test() {
  function test_multifunction_node (line 732) | void test_multifunction_node() {
  function run_one_continue_node_test (line 796) | void run_one_continue_node_test (bool throwException, bool flog) {
  function run_continue_node_test (line 867) | void run_continue_node_test() {
  function test_continue_node (line 892) | void test_continue_node() {
  function run_one_buffer_node_test (line 917) | void run_one_buffer_node_test(bool throwException,bool flog) {
  function run_buffer_queue_and_overwrite_node_test (line 988) | void run_buffer_queue_and_overwrite_node_test() {
  function test_buffer_queue_and_overwrite_node (line 1029) | void test_buffer_queue_and_overwrite_node() {
  function run_one_sequencer_node_test (line 1051) | void run_one_sequencer_node_test(bool throwException,bool flog) {
  function run_sequencer_node_test (line 1122) | void run_sequencer_node_test() {
  function test_sequencer_node (line 1149) | void test_sequencer_node() {
  function run_one_priority_queue_node_test (line 1171) | void run_one_priority_queue_node_test(bool throwException,bool flog) {
  function run_priority_queue_node_test (line 1246) | void run_priority_queue_node_test() {
  function test_priority_queue_node (line 1270) | void test_priority_queue_node() {
  type graph_policy_name (line 1284) | struct graph_policy_name{
  type graph_policy_name<tbb::flow::queueing> (line 1287) | struct graph_policy_name<tbb::flow::queueing>  {
  type graph_policy_name<tbb::flow::reserving> (line 1290) | struct graph_policy_name<tbb::flow::reserving> {
  type graph_policy_name<tbb::flow::tag_matching> (line 1293) | struct graph_policy_name<tbb::flow::tag_matching> {
  type run_one_join_node_test (line 1309) | struct run_one_join_node_test {
    method run_one_join_node_test (line 1310) | run_one_join_node_test() {}
    method execute_test (line 1311) | static void execute_test(bool throwException,bool flog) {
  type run_one_join_node_test<
        tbb::flow::tag_matching,
        OutputTuple,
        InputType0,
        InputBodyType0,
        InputType1,
        InputBodyType1,
        TestJoinType,
        SinkType,
        SinkBodyType
    > (line 1408) | struct run_one_join_node_test<
    method run_one_join_node_test (line 1419) | run_one_join_node_test() {}
    method execute_test (line 1420) | static void execute_test(bool throwException,bool flog) {
  function run_join_node_test (line 1505) | void run_join_node_test() {
  function test_join_node (line 1535) | void test_join_node() {
  function run_one_limiter_node_test (line 1558) | void run_one_limiter_node_test(bool throwException,bool flog) {
  function run_limiter_node_test (line 1633) | void run_limiter_node_test() {
  function test_limiter_node (line 1656) | void test_limiter_node() {
  function run_one_split_node_test (line 1678) | void run_one_split_node_test(bool throwException, bool flog) {
  function run_split_node_test (line 1744) | void run_split_node_test() {
  function test_split_node (line 1773) | void test_split_node() {
  function run_one_indexer_node_test (line 1794) | void run_one_indexer_node_test(bool throwException,bool flog) {
  function run_indexer_node_test (line 1878) | void run_indexer_node_test() {
  function test_indexer_node (line 1906) | void test_indexer_node() {
  class Foo (line 1920) | class Foo {
    method Foo (line 1925) | Foo(std::vector<int>& vec) : m_vec(&vec) { }
  function test_flow_graph_exception0 (line 1935) | void
  function TestOneThreadNum (line 1982) | void TestOneThreadNum(int nThread) {

FILE: third-party/tbb/test/tbb/test_eh_thread.cpp
  function limitThreads (line 44) | void limitThreads(size_t limit)
  function getThreadLimit (line 57) | size_t getThreadLimit() {
  class Thread (line 70) | class Thread {
    method Thread (line 74) | Thread() {
    method isValid (line 83) | bool isValid() const { return mValid; }
    method join (line 84) | void join() {

FILE: third-party/tbb/test/tbb/test_enumerable_thread_specific.cpp
  class minimalN (line 57) | class minimalN: utils::NoAssign {
    method minimalN (line 63) | minimalN() : utils::NoAssign(), my_value(0) { ++construction_counter; ...
    method minimalN (line 64) | minimalN( const minimalN&m ) : utils::NoAssign(), my_value(m.my_value)...
    method set_value (line 66) | void set_value( const int i ) { REQUIRE(is_constructed); my_value = i; }
    method value (line 67) | int value( ) const { REQUIRE(is_constructed); return my_value; }
  function T (line 73) | T& check_alignment(T& t, const char *aname) {
  function T (line 82) | const T& check_alignment(const T& t, const char *aname) {
  class set_body (line 99) | class set_body {
    method set_body (line 103) | set_body( flogged_ets*_a ) : a(_a) { }
  function do_std_threads (line 113) | void do_std_threads( int max_threads, flogged_ets a[] ) {
  function flog_key_creation_and_deletion (line 129) | void flog_key_creation_and_deletion() {
  function flog_segmented_interator (line 181) | void flog_segmented_interator() {
  function flog_segmented_iterator_map (line 282) | void flog_segmented_iterator_map() {
  function run_segmented_iterator_tests (line 318) | void run_segmented_iterator_tests() {
  function align_val (line 331) | int align_val(void * const p) {
  function is_between (line 338) | bool is_between(void* lowp, void *highp, void *testp) {
  type alignment_of (line 343) | struct alignment_of {
  function allocate_ets_element_on_stack (line 349) | void allocate_ets_element_on_stack(const char* /* name */) {
  class BigType (line 366) | class BigType {
    method BigType (line 368) | BigType() { /* avoid cl warning C4345 about default initialization of ...
  function TestConstructorWithBigType (line 373) | void TestConstructorWithBigType(const char* allocator_name) {
  function init_tbb_alloc_mask (line 385) | size_t init_tbb_alloc_mask() {

FILE: third-party/tbb/test/tbb/test_environment_whitebox.cpp
  function set_and_get_test_variable (line 50) | void set_and_get_test_variable( T (*environment_variable_getter)( const ...
  type RandomCharacterGenerator (line 61) | struct RandomCharacterGenerator {
  function alternative_env_variable_checker (line 67) | bool alternative_env_variable_checker( const char* str, bool ) {
  function alternative_env_variable_checker (line 84) | long alternative_env_variable_checker( const char* str, long ) {
  function create_random_case (line 102) | std::pair<std::string, T> create_random_case( std::size_t length ) {
  function prepare_random_cases (line 113) | void prepare_random_cases( std::vector<std::pair<std::string, T>>& cases...
  function initialize_cases (line 125) | std::vector<std::pair<std::string, bool>> initialize_cases( bool wrong_r...
  function initialize_cases (line 159) | std::vector<std::pair<std::string, long>> initialize_cases( long wrong_r...
  function test_environment_variable (line 217) | void test_environment_variable( T (*environment_variables_handler)( cons...

FILE: third-party/tbb/test/tbb/test_flow_graph.cpp
  type decrement_wait (line 37) | struct decrement_wait : utils::NoAssign {
    method decrement_wait (line 42) | decrement_wait( tbb::flow::graph &h, bool *done_flag ) : my_graph(&h),...
  function test_wait_count (line 52) | static void test_wait_count() {
  class my_int_buffer (line 72) | class my_int_buffer {
    method my_int_buffer (line 76) | my_int_buffer(tbb::flow::graph &g) : my_graph(g) { b = new tbb::flow::...
    method my_int_buffer (line 77) | my_int_buffer(const my_int_buffer& other) : my_graph(other.my_graph) {
    method my_int_buffer (line 81) | my_int_buffer& operator=(const my_int_buffer& /*other*/) {
  function test_iterator (line 87) | void test_iterator() {
  class AddRemoveBody (line 119) | class AddRemoveBody : utils::NoAssign {
    method AddRemoveBody (line 124) | AddRemoveBody(int nthr, utils::SpinBarrier &barrier_, tbb::flow::graph...
  function test_parallel (line 151) | void test_parallel(int nThreads) {
  function check_arena (line 162) | inline void check_arena(tbb::task_arena* midway_arena) {
  type run_functor (line 167) | struct run_functor {
    method run_functor (line 170) | run_functor(tbb::task_arena* a) : midway_arena(a), return_value(1) {}
  type function_body (line 178) | struct function_body {
    method function_body (line 180) | function_body(tbb::task_arena* a) : midway_arena(a) {}
  type multifunction_body (line 189) | struct multifunction_body {
    method multifunction_body (line 191) | multifunction_body(tbb::task_arena* a) : midway_arena(a) {}
  type input_body (line 197) | struct input_body {
    method input_body (line 200) | input_body(tbb::task_arena* a) : midway_arena(a), counter(0) {}
  type nodes_test_functor (line 210) | struct nodes_test_functor : utils::NoAssign {
    method nodes_test_functor (line 214) | nodes_test_functor(tbb::task_arena* a, tbb::flow::graph& g) : midway_a...
  function test_graph_arena (line 281) | void test_graph_arena() {

FILE: third-party/tbb/test/tbb/test_flow_graph_priorities.cpp
  type TaskInfo (line 46) | struct TaskInfo {
    method TaskInfo (line 47) | TaskInfo() : my_priority(-1), my_task_index(-1) {}
    method TaskInfo (line 48) | TaskInfo( int priority, int task_index )
  function spin_for (line 58) | void spin_for( double delta ) {
  type PriorityNodesTakePrecedence (line 63) | namespace PriorityNodesTakePrecedence {
    function body_func (line 72) | void body_func( int priority, utils::SpinBarrier& my_barrier ) {
    type Body (line 87) | struct Body {
      method Body (line 88) | Body( int priority, utils::SpinBarrier& barrier )
      method T (line 90) | T operator()( const T& msg ) const {
    type node_creator_t (line 104) | struct node_creator_t {
      method NodeType (line 105) | NodeType* operator()( graph& g, unsigned index, utils::SpinBarrier& ...
    type node_creator_t< continue_node<continue_msg>, BodyType > (line 114) | struct node_creator_t< continue_node<continue_msg>, BodyType > {
    type passthru_body (line 124) | struct passthru_body {
      method continue_msg (line 126) | continue_msg operator()( T ) const { return continue_msg(); }
    function test_node (line 130) | void test_node( NodeTypeCreator node_creator ) {
    function call_within_arena (line 196) | void call_within_arena( tbb::task_arena& arena ) {
    function test (line 204) | void test( int num_threads ) {
  type ThreadsEagerReaction (line 214) | namespace ThreadsEagerReaction {
    class concurrent_queue (line 218) | class concurrent_queue {
      method try_pop (line 220) | bool try_pop(T& item) {
      method push (line 229) | void push(const T& item) {
    type task_type_t (line 241) | enum task_type_t { no_task, regular_task, async_task }
    type profile_t (line 243) | struct profile_t {
    type AsyncActivity (line 255) | struct AsyncActivity {
      type work_type (line 258) | struct work_type { data_type input; gateway_type* gateway; }
      type ServiceThreadFunc (line 263) | struct ServiceThreadFunc {
        method ServiceThreadFunc (line 265) | ServiceThreadFunc(SpinBarrier& barrier) : my_barrier(barrier) {}
      method stop_and_wait (line 278) | void stop_and_wait() { done = true; my_service_thread.join(); }
      method submit (line 280) | void submit(data_type input, gateway_type* gateway) {
      method AsyncActivity (line 285) | AsyncActivity(SpinBarrier& barrier)
    type StartBody (line 289) | struct StartBody {
      method data_type (line 291) | data_type operator()(tbb::flow_control& fc) {
      method StartBody (line 299) | StartBody() : has_run(false) {}
    type ParallelForBody (line 302) | struct ParallelForBody {
      method ParallelForBody (line 305) | ParallelForBody(SpinBarrier& barrier, const data_type& input)
    type CpuWorkBody (line 313) | struct CpuWorkBody {
      method data_type (line 316) | data_type operator()(const data_type& input) {
      method CpuWorkBody (line 320) | CpuWorkBody(SpinBarrier& barrier, int tasks_count)
    type DeciderBody (line 324) | struct DeciderBody {
      method DeciderBody (line 326) | DeciderBody( const data_type& limit ) : my_limit( limit ) {}
    type AsyncSubmissionBody (line 333) | struct AsyncSubmissionBody {
      method AsyncSubmissionBody (line 342) | AsyncSubmissionBody(AsyncActivity* activity) : my_activity(activity) {}
    function test (line 345) | void test( unsigned num_threads ) {
  type LimitingExecutionToPriorityTask (line 405) | namespace LimitingExecutionToPriorityTask {
    type work_type_t (line 407) | enum work_type_t { NONPRIORITIZED_WORK, PRIORITIZED_WORK }
    type execution_tracker_t (line 409) | struct execution_tracker_t {
      method execution_tracker_t (line 410) | execution_tracker_t() { reset(); }
      method reset (line 411) | void reset() {
    type CommonBody (line 430) | struct CommonBody {
      method CommonBody (line 431) | CommonBody() : my_body_size( 0 ) { }
      method CommonBody (line 432) | CommonBody( int body_size ) : my_body_size( body_size ) { }
      method continue_msg (line 433) | continue_msg operator()( const continue_msg& msg ) const {
    function do_node_work (line 444) | void do_node_work(int work_size) {
    function do_nested_work (line 450) | void do_nested_work( const std::thread::id& tid, const tbb::blocked_ra...
    type IsolationFunctor (line 464) | struct IsolationFunctor {
      method IsolationFunctor (line 466) | IsolationFunctor(int ws) : work_size(ws) {}
    function create_nodes (line 498) | void create_nodes( nodes_container_t& nodes, graph& g, int num, int bo...
    function test (line 507) | void test( int num_threads ) {
  type NestedCase (line 549) | namespace NestedCase {
    type InnerBody (line 553) | struct InnerBody {
      method continue_msg (line 554) | continue_msg operator()( const continue_msg& ) const {
    type OuterBody (line 559) | struct OuterBody {
      method OuterBody (line 562) | OuterBody( int max_threads, task_arena** inner_arena )
      method OuterBody (line 565) | OuterBody( const OuterBody& rhs )
    function execute_outer_graph (line 584) | void execute_outer_graph( bool same_arena, task_arena& inner_arena, in...
    function test_in_arena (line 601) | void test_in_arena( int max_threads, task_arena& outer_arena, task_are...
    function test (line 616) | void test( int max_threads ) {
  type BypassPrioritizedTask (line 651) | namespace BypassPrioritizedTask {
    function common_body (line 653) | void common_body( int priority ) {
    type Body (line 658) | struct Body {
      method Body (line 659) | Body( int priority ) : my_priority( priority ) {}
      method continue_msg (line 660) | continue_msg operator()(const continue_msg&) {
    type InputNodeBody (line 667) | struct InputNodeBody {
      method continue_msg (line 668) | continue_msg operator()( tbb::flow_control& fc ){
    function StarterNodeType (line 684) | StarterNodeType create_starter_node(graph& g) {
    function start_graph (line 694) | void start_graph( StarterNodeType& starter ) {
    function test_use_case (line 704) | void test_use_case() {
    function test (line 730) | void test() {
  type ManySuccessors (line 737) | namespace ManySuccessors {
    type no_priority_node_body (line 739) | struct no_priority_node_body {
    type priority_node_body (line 748) | struct priority_node_body {
    function test (line 757) | void test(int num_threads) {
  type Exceptions (line 798) | namespace Exceptions {
    function test (line 799) | void test() {

FILE: third-party/tbb/test/tbb/test_flow_graph_whitebox.cpp
  type receiverBody (line 50) | struct receiverBody {
  function TestSplitNode (line 59) | void TestSplitNode() {
  function TestBufferingNode (line 81) | void TestBufferingNode(const char * name) {
  function TestContinueNode (line 149) | void TestContinueNode() {
  function TestFunctionNode (line 234) | void TestFunctionNode() {
  class tag_func (line 344) | class tag_func {
    method tag_func (line 347) | tag_func(TT multiplier) : my_mult(multiplier) { }
  function TestSimpleSuccessorArc (line 356) | void
  function TestJoinNode (line 393) | void
  type limiter_node_type (line 438) | struct limiter_node_type {
  type limiter_node_type<void> (line 444) | struct limiter_node_type<void> {
  type DecrementerHelper (line 450) | struct DecrementerHelper {
    method check (line 452) | static void check(Decrementer&) {}
    method DType (line 453) | static DType makeDType() {
  type DecrementerHelper<tbb::flow::continue_msg> (line 459) | struct DecrementerHelper<tbb::flow::continue_msg> {
    method check (line 461) | static void check(Decrementer& decrementer) {
    method makeDType (line 467) | static tbb::flow::continue_msg makeDType() {
  function TestLimiterNode (line 473) | void TestLimiterNode() {
  type mf_body (line 535) | struct mf_body {
    method mf_body (line 537) | mf_body(std::atomic<int>& flag) : my_flag(flag) { }
  type test_reversal (line 553) | struct test_reversal
  type test_reversal<tbb::flow::queueing, T> (line 555) | struct test_reversal<tbb::flow::queueing, T> {
    method test_reversal (line 556) | test_reversal() { INFO("<queueing>"); }
  type test_reversal<tbb::flow::rejecting, T> (line 562) | struct test_reversal<tbb::flow::rejecting, T> {
    method test_reversal (line 563) | test_reversal() { INFO("<rejecting>"); }
  function TestMultifunctionNode (line 568) | void TestMultifunctionNode() {
  function TestIndexerNode (line 622) | void
  function TestScalarNode (line 640) | void
  type seq_body (line 656) | struct seq_body {
  function TestSequencerNode (line 663) | void TestSequencerNode() {
  type snode_body (line 707) | struct snode_body {
    method snode_body (line 710) | snode_body(const int& in) : max_cnt(in) { my_cnt = 0; }
  function TestInputNode (line 720) | void TestInputNode() {

FILE: third-party/tbb/test/tbb/test_function_node.cpp
  type pass_through (line 50) | struct pass_through {
    method IO (line 51) | IO operator()(const IO& i) { return i; }
  function buffered_levels (line 55) | void buffered_levels( size_t concurrency, Body body ) {
  type inc_functor (line 144) | struct inc_functor {
    method inc_functor (line 147) | inc_functor( ) { local_execute_count = 0; }
    method inc_functor (line 148) | inc_functor( const inc_functor &f ) { local_execute_count = size_t(f.l...
  function buffered_levels_with_copy (line 160) | void buffered_levels_with_copy( size_t concurrency ) {
  function run_buffered_levels (line 233) | void run_buffered_levels( int c ) {
  function concurrency_levels (line 251) | void concurrency_levels( size_t concurrency, Body body ) {
  function run_concurrency_levels (line 332) | void run_concurrency_levels( int c ) {
  type empty_no_assign (line 339) | struct empty_no_assign {
    method empty_no_assign (line 340) | empty_no_assign() {}
    method empty_no_assign (line 341) | empty_no_assign( int ) {}
  type parallel_puts (line 346) | struct parallel_puts : private utils::NoAssign {
    method parallel_puts (line 350) | parallel_puts( tbb::flow::receiver< InputType > &exe_node ) : my_exe_n...
  function unlimited_concurrency (line 370) | void unlimited_concurrency( Body body ) {
  function run_unlimited_concurrency (line 408) | void run_unlimited_concurrency() {
  type continue_msg_to_int (line 415) | struct continue_msg_to_int {
    method continue_msg_to_int (line 417) | continue_msg_to_int(int x) : my_int(x) {}
  function test_function_node_with_continue_msg_as_input (line 421) | void test_function_node_with_continue_msg_as_input() {
  function test_concurrency (line 438) | void test_concurrency(int num_threads) {
  function test_follows_and_precedes_api (line 455) | void test_follows_and_precedes_api() {
  function test_try_put_and_wait_lightweight (line 480) | void test_try_put_and_wait_lightweight(std::size_t concurrency_limit) {
  function test_try_put_and_wait_queueing (line 564) | void test_try_put_and_wait_queueing(std::size_t concurrency_limit) {
  function test_try_put_and_wait_rejecting (line 651) | void test_try_put_and_wait_rejecting(size_t concurrency_limit) {
  function test_try_put_and_wait (line 717) | void test_try_put_and_wait() {
  type InputObject (line 764) | struct InputObject {
    method InputObject (line 765) | InputObject() = default;
    method InputObject (line 766) | InputObject( const InputObject& ) = default;
  type OutputObject (line 768) | struct OutputObject : test_concepts::Copyable {}

FILE: third-party/tbb/test/tbb/test_fuzzing.cpp
  function LLVMFuzzerTestOneInput (line 22) | int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {

FILE: third-party/tbb/test/tbb/test_global_control.cpp
  type task_scheduler_handle_guard (line 33) | struct task_scheduler_handle_guard {
    method task_scheduler_handle_guard (line 36) | task_scheduler_handle_guard() {
  type TestBlockingTerminateNS (line 49) | namespace TestBlockingTerminateNS {
    type TestAutoInitBody (line 51) | struct TestAutoInitBody {
    class TestMultpleWaitBody (line 60) | class TestMultpleWaitBody {
      method TestMultpleWaitBody (line 63) | TestMultpleWaitBody( bool autoInit = false ) : myAutoInit( autoInit ...
    function TestMultpleWait (line 110) | void TestMultpleWait() {
    function TestException (line 127) | void TestException( F &f ) {
    class ExceptionTest1 (line 145) | class ExceptionTest1 {
      method ExceptionTest1 (line 150) | ExceptionTest1( int index ) : myIndex( index ) {}
    type ExceptionTest2 (line 160) | struct ExceptionTest2 {
      class Body (line 161) | class Body {
        method Body (line 164) | Body( utils::SpinBarrier& barrier ) : myBarrier( barrier ) {}
    function TestExceptions (line 184) | void TestExceptions() {
  function TestTerminationAndAutoinit (line 201) | void TestTerminationAndAutoinit(bool autoinit) {

FILE: third-party/tbb/test/tbb/test_handle_perror.cpp
  type tbb (line 34) | namespace tbb {
    type detail (line 35) | namespace detail {
      type r1 (line 36) | namespace r1 {
        function terminate_on_exception (line 37) | bool terminate_on_exception() {

FILE: third-party/tbb/test/tbb/test_indexer_node.cpp
  function check_outputCheck (line 44) | void
  function reset_outputCheck (line 53) | void
  class test_class (line 62) | class test_class {
    method test_class (line 64) | test_class() { my_val = 0; }
    method test_class (line 65) | test_class(int i) { my_val = i; }
  class name_of (line 72) | class name_of {
  class name_of<int> (line 77) | class name_of<int> {
  class name_of<float> (line 82) | class name_of<float> {
  class name_of<double> (line 87) | class name_of<double> {
  class name_of<long> (line 92) | class name_of<long> {
  class name_of<short> (line 97) | class name_of<short> {
  class name_of<test_class> (line 102) | class name_of<test_class> {
  class my_input_body (line 115) | class my_input_body {
    method my_input_body (line 120) | my_input_body(TT multiplier, int init_val, int addto) : my_mult(multip...
    method TT (line 121) | TT operator()( tbb::flow_control& fc) {
  class makeIndexer (line 137) | class makeIndexer {
    method IType (line 139) | static IType *create() {
    method destroy (line 143) | static void destroy(IType *p) { delete p; }
  type getval_helper (line 147) | struct getval_helper {
    method get_integer_val (line 152) | static int get_integer_val(OT const &o) {
  class input_node_helper (line 163) | class input_node_helper {
    method print_remark (line 169) | static void print_remark() {
    method add_input_nodes (line 173) | static void add_input_nodes(indexer_node_type &my_indexer, tbb::flow::...
    method check_value (line 185) | static void check_value(TT &v) {
    method remove_input_nodes (line 198) | static void remove_input_nodes(indexer_node_type& my_indexer, int nInp...
  class input_node_helper<1, INT> (line 209) | class input_node_helper<1, INT> {
    method print_remark (line 216) | static void print_remark() {
    method add_input_nodes (line 219) | static void add_input_nodes(indexer_node_type &my_indexer, tbb::flow::...
    method check_value (line 227) | static void check_value(TT &v) {
    method remove_input_nodes (line 234) | static void remove_input_nodes(indexer_node_type& my_indexer, int nInp...
  class parallel_test (line 244) | class parallel_test {
    method test (line 249) | static void test() {
  class serial_queue_helper (line 301) | class serial_queue_helper {
    method print_remark (line 306) | static void print_remark() {
    method fill_one_queue (line 310) | static void fill_one_queue(int maxVal, IType &my_indexer) {
    method put_one_queue_val (line 317) | static void put_one_queue_val(int myVal, IType &my_indexer) {
    method check_queue_value (line 322) | static void check_queue_value(OT &v) {
  class serial_queue_helper<1, IType> (line 336) | class serial_queue_helper<1, IType> {
    method print_remark (line 341) | static void print_remark() {
    method fill_one_queue (line 344) | static void fill_one_queue(int maxVal, IType &my_indexer) {
    method put_one_queue_val (line 349) | static void put_one_queue_val(int myVal, IType &my_indexer) {
    method check_queue_value (line 352) | static void check_queue_value(OT &v) {
  function test_one_serial (line 361) | void test_one_serial( IType &my_indexer, tbb::flow::graph &g) {
  function test_input_ports_return_ref (line 403) | void test_input_ports_return_ref(NodeType& mip_node) {
  class serial_test (line 414) | class serial_test {
    method test (line 419) | static void test() {
  class generate_test (line 445) | class generate_test {
    method do_test (line 448) | static void do_test() {
  class generate_test<TestType, T0, T1, T2, T3, T4, T5, T6, T7, T8> (line 458) | class generate_test<TestType, T0, T1, T2, T3, T4, T5, T6, T7, T8> {
    method do_test (line 461) | static void do_test() {
  class generate_test<TestType, T0, T1, T2, T3, T4, T5, T6, T7> (line 470) | class generate_test<TestType, T0, T1, T2, T3, T4, T5, T6, T7> {
    method do_test (line 473) | static void do_test() {
  class generate_test<TestType, T0, T1, T2, T3, T4, T5, T6> (line 482) | class generate_test<TestType, T0, T1, T2, T3, T4, T5, T6> {
    method do_test (line 485) | static void do_test() {
  class generate_test<TestType, T0, T1, T2, T3, T4, T5> (line 494) | class generate_test<TestType, T0, T1, T2, T3, T4, T5>  {
    method do_test (line 497) | static void do_test() {
  class generate_test<TestType, T0, T1, T2, T3, T4> (line 505) | class generate_test<TestType, T0, T1, T2, T3, T4>  {
    method do_test (line 508) | static void do_test() {
  class generate_test<TestType, T0, T1, T2, T3> (line 516) | class generate_test<TestType, T0, T1, T2, T3> {
    method do_test (line 519) | static void do_test() {
  class generate_test<TestType, T0, T1, T2> (line 527) | class generate_test<TestType, T0, T1, T2> {
    method do_test (line 530) | static void do_test() {
  class generate_test<TestType, T0, T1> (line 538) | class generate_test<TestType, T0, T1> {
    method do_test (line 541) | static void do_test() {
  class generate_test<TestType, T0> (line 549) | class generate_test<TestType, T0> {
    method do_test (line 552) | static void do_test() {
  function check_edge (line 559) | bool check_edge(tbb::flow::graph& g,
  function sink (line 575) | void sink(T...) {}
  function check_edge (line 578) | void check_edge(tbb::flow::graph& g, BN& bn, tbb::flow::buffer_node<inde...
  function test_follows_impl (line 583) | void test_follows_impl(std::tuple<Args...> t, tbb::detail::index_sequenc...
  function test_follows (line 599) | void test_follows() {
  function test_precedes (line 603) | void test_precedes() {
  function test_follows_and_precedes_api (line 629) | void test_follows_and_precedes_api() {
  function test_deduction_guides (line 645) | void test_deduction_guides() {
  function test_try_put_and_wait (line 665) | void test_try_put_and_wait() {

FILE: third-party/tbb/test/tbb/test_input_node.cpp
  class test_push_receiver (line 39) | class test_push_receiver : public tbb::flow::receiver<T>, utils::NoAssign {
    method test_push_receiver (line 46) | test_push_receiver(tbb::flow::graph& g) : my_graph(g) {
    method get_count (line 51) | int get_count( int i ) {
    method graph_task (line 58) | graph_task* try_put_task( const T &v ) override {
    method graph_task (line 65) | graph_task* try_put_task( const T& v, const tbb::detail::d2::message_m...
  class my_input_body (line 76) | class my_input_body {
    method my_input_body (line 83) | my_input_body() : ninvocations(nullptr) { my_count = 0; }
    method my_input_body (line 84) | my_input_body(int &_inv) : ninvocations(&_inv)  { my_count = 0; }
    method T (line 86) | T operator()( tbb::flow_control& fc ) {
  class function_body (line 100) | class function_body {
    method function_body (line 106) | function_body( std::atomic<int> *counters ) : my_counters(counters) {
  function test_single_dest (line 119) | void test_single_dest() {
  function test_reset (line 170) | void test_reset() {
  function test_follows_and_precedes_api (line 265) | void test_follows_and_precedes_api() {
  type Object (line 339) | struct Object : test_concepts::Copyable, test_concepts::CopyAssignable {}

FILE: third-party/tbb/test/tbb/test_intrusive_list.cpp
  type VerificationBase (line 29) | struct VerificationBase : utils::NoAfterlife {
    method VerificationBase (line 31) | VerificationBase() : m_Canary(NoliMeTangere) {}
  type DataItemWithInheritedNodeBase (line 34) | struct DataItemWithInheritedNodeBase : intrusive_list_node {
    method DataItemWithInheritedNodeBase (line 37) | DataItemWithInheritedNodeBase( int value ) : m_Data(value) {}
    method Data (line 39) | int Data() const { return m_Data; }
  type DataItemWithInheritedNode (line 42) | struct DataItemWithInheritedNode : VerificationBase, DataItemWithInherit...
    method DataItemWithInheritedNode (line 45) | DataItemWithInheritedNode( int value ) : DataItemWithInheritedNodeBase...
  type DataItemWithMemberNodeBase (line 48) | struct DataItemWithMemberNodeBase {
    method DataItemWithMemberNodeBase (line 54) | DataItemWithMemberNodeBase( int value ) : m_Data(value) {}
    method Data (line 56) | int Data() const { return m_Data; }
  type DataItemWithMemberNodes (line 59) | struct DataItemWithMemberNodes : VerificationBase, DataItemWithMemberNod...
    method DataItemWithMemberNodes (line 62) | DataItemWithMemberNodes( int value ) : DataItemWithMemberNodeBase(valu...
  function check_list_nodes (line 78) | void check_list_nodes( List& il, int value_step ) {
  function test_list_operations (line 104) | void test_list_operations() {

FILE: third-party/tbb/test/tbb/test_join_node.cpp
  class recirc_output_func_body (line 35) | class recirc_output_func_body {
  class tag_recirculation_test (line 49) | class tag_recirculation_test {
    method test (line 55) | static void test() {
  class generate_recirc_test (line 117) | class generate_recirc_test {
    method do_test (line 120) | static void do_test() {

FILE: third-party/tbb/test/tbb/test_join_node.h
  function K (line 62) | K operator()(const int indx) {
  function string (line 68) | struct index_to_key<std::string> {
  type K (line 76) | typedef K type;
  type K (line 81) | typedef K type;
  type MyKeySecond (line 97) | struct MyKeySecond {
  function K (line 235) | K operator()(const V& mv) {
  type type_to_key_function_body (line 254) | typedef type_to_key_function_body<V, K> type;
  type tbb_hash_compare (line 257) | typedef tbb_hash_compare<K> type;
  type typename (line 261) | typedef typename K_deref<K>::type KnoR;
  type type_to_key_function_body_leaf (line 269) | typedef type_to_key_function_body_leaf<
  function TestTaggedBuffers (line 343) | void
  type threebyte (line 353) | struct threebyte {
  function check_outputCheck (line 372) | void
  function reset_outputCheck (line 381) | void
  type message_based_key_matching (line 449) | struct message_based_key_matching {}
  type key_type (line 455) | typedef int key_type;
  type K (line 464) | typedef K key_type;
  type K (line 473) | typedef K key_type;
  function my_mult (line 486) | recirc_func_body(TT multiplier): my_mult(multiplier) {}
  function my_mult (line 487) | recirc_func_body(const recirc_func_body &other): my_mult(other.my_mult) { }
  function TT (line 489) | TT operator()(const input_type &v) {
  function class (line 497) | class recirc_input_node_body {
  type JP (line 546) | typedef JP policy;
  function destroy (line 565) | static void destroy(JType *p) { delete p; }
  type typename (line 572) | typedef typename JType::output_type TType;
  function destroy (line 583) | static void destroy(JType *p) { delete p; }
  type typename (line 588) | typedef typename JType::output_type TType;
  function destroy (line 599) | static void destroy(JType *p) { delete p; }
  type typename (line 605) | typedef typename JType::output_type TType;
  function destroy (line 618) | static void destroy(JType *p) { delete p; }
  type typename (line 623) | typedef typename JType::output_type TType;
  function destroy (line 636) | static void destroy(JType *p) { delete p; }
  type typename (line 644) | typedef typename JType::output_type TType;
  function destroy (line 659) | static void destroy(JType *p) { delete p; }
  type typename (line 664) | typedef typename JType::output_type TType;
  function destroy (line 679) | static void destroy(JType *p) { delete p; }
  type typename (line 686) | typedef typename JType::output_type TType;
  function destroy (line 703) | static void destroy(JType *p) { delete p; }
  type typename (line 708) | typedef typename JType::output_type TType;
  function destroy (line 725) | static void destroy(JType *p) { delete p; }
  type typename (line 731) | typedef typename JType::output_type TType;
  function destroy (line 750) | static void destroy(JType *p) { delete p; }
  type typename (line 755) | typedef typename JType::output_type TType;
  function destroy (line 774) | static void destroy(JType *p) { delete p; }
  type typename (line 781) | typedef typename JType::output_type TType;
  function destroy (line 802) | static void destroy(JType *p) { delete p; }
  type typename (line 807) | typedef typename JType::output_type TType;
  function destroy (line 828) | static void destroy(JType *p) { delete p; }
  type typename (line 835) | typedef typename JType::output_type TType;
  function destroy (line 858) | static void destroy(JType *p) { delete p; }
  type typename (line 863) | typedef typename JType::output_type TType;
  function destroy (line 886) | static void destroy(JType *p) { delete p; }
  type typename (line 893) | typedef typename JType::output_type TType;
  function destroy (line 918) | static void destroy(JType *p) { delete p; }
  type typename (line 923) | typedef typename JType::output_type TType;
  function destroy (line 948) | static void destroy(JType *p) { delete p; }
  type typename (line 955) | typedef typename JType::output_type TType;
  function destroy (line 982) | static void destroy(JType *p) { delete p; }
  type typename (line 987) | typedef typename JType::output_type TType;
  function destroy (line 1014) | static void destroy(JType *p) { delete p; }
  type tbb (line 1026) | typedef tbb::flow::join_node<std::tuple<int, tbb::flow::continue_msg>, t...
  type typename (line 1027) | typedef typename join_node_type::output_type TT;
  type typename (line 1029) | typedef typename std::tuple_element<ELEM
  type typename (line 1030) | typedef typename tbb::flow::input_node<IT> my_input_node_type;
  type typename (line 1031) | typedef typename tbb::flow::function_node<std::tuple<int, tbb::flow::con...
  function print_remark (line 1032) | static void print_remark(const char * str) {
  function add_input_nodes (line 1036) | static void add_input_nodes(join_node_type &my_join, tbb::flow::graph &g...
  function add_recirc_func_nodes (line 1047) | static void add_recirc_func_nodes(join_node_type &my_join, input_join_ty...
  function only_check_value (line 1055) | static void only_check_value(const int i, const TT &v) {
  function check_value (line 1060) | static void check_value(int i, TT &v, bool is_serial) {
  function remove_input_nodes (line 1072) | static void remove_input_nodes(join_node_type& my_join, int nInputs) {
  function remove_recirc_func_nodes (line 1081) | static void remove_recirc_func_nodes(join_node_type& my_join, input_join...
  type JNT (line 1092) | typedef JNT join_node_type;
  type tbb (line 1093) | typedef tbb::flow::join_node<std::tuple<int, tbb::flow::continue_msg>, t...
  type typename (line 1094) | typedef typename join_node_type::output_type TT;
  type typename (line 1097) | typedef typename tbb::flow::input_node<IT> my_input_node_type;
  type typename (line 1098) | typedef typename tbb::flow::function_node<std::tuple<int, tbb::flow::con...
  function add_input_nodes (line 1103) | static void add_input_nodes(join_node_type &my_join, tbb::flow::graph &g...
  function add_recirc_func_nodes (line 1112) | static void add_recirc_func_nodes(join_node_type &my_join, input_join_ty...
  function only_check_value (line 1119) | static void only_check_value(const int i, const TT &v) {
  function check_value (line 1123) | static void check_value(int i, TT &v, bool is_serial) {
  function remove_input_nodes (line 1132) | static void remove_input_nodes(join_node_type& my_join, int nInputs) {
  function remove_recirc_func_nodes (line 1140) | static void remove_recirc_func_nodes(join_node_type& my_join, input_join...
  type typename (line 1158) | typedef typename is_key_matching_join<JP>::key_type            key_type;
  function test (line 1159) | static void test() {
  type typename (line 1223) | typedef typename std::tuple_element<ELEM
  type typename (line 1224) | typedef typename tbb::flow::queue_node<IT> my_queue_node_type;
  function print_remark (line 1225) | static void print_remark() {
  function add_queue_nodes (line 1229) | static void add_queue_nodes(tbb::flow::graph &g, JType &my_join) {
  function fill_one_queue (line 1236) | static void fill_one_queue(int maxVal) {
  function put_one_queue_val (line 1245) | static void put_one_queue_val(int myVal) {
  function check_queue_value (line 1252) | static void check_queue_value(int i, TT &v) {
  function remove_queue_nodes (line 1257) | static void remove_queue_nodes(JType &my_join) {
  type typename (line 1270) | typedef typename tbb::flow::queue_node<IT> my_queue_node_type;
  function print_remark (line 1271) | static void print_remark() {
  function add_queue_nodes (line 1275) | static void add_queue_nodes(tbb::flow::graph &g, JType &my_join) {
  function fill_one_queue (line 1281) | static void fill_one_queue(int maxVal) {
  function put_one_queue_val (line 1288) | static void put_one_queue_val(int myVal) {
  function check_queue_value (line 1294) | static void check_queue_value(int i, TT &v) {
  function remove_queue_nodes (line 1298) | static void remove_queue_nodes(JType &my_join) {
  type typename (line 1312) | typedef typename JType::output_type TType;
  type TType (line 1317) | typedef TType q3_input_type;
  type typename (line 1384) | typedef typename JType::output_type TType;
  function do_test (line 1430) | static void do_test() {
  function test_input_port_policies (line 1454) | void test_input_port_policies<tbb::flow::reserving>() {
  function test_input_port_policies (line 1539) | void test_input_port_policies<tbb::flow::queueing>() {
  type myTagValue (line 1605) | struct myTagValue
  function test_input_port_policies (line 1631) | void test_input_port_policies<tbb::flow::tag_matching>() {
  function queueing (line 1734) | struct policy_name<tbb::flow::queueing> {
  function reserving (line 1739) | struct policy_name<tbb::flow::reserving> {
  function tag_matching (line 1744) | struct policy_name<tbb::flow::tag_matching> {

FILE: third-party/tbb/test/tbb/test_join_node_key_matching.cpp
  function test_deduction_guides (line 27) | void test_deduction_guides() {
  type tuple_helper (line 82) | struct tuple_helper {
  type tuple_helper<1> (line 87) | struct tuple_helper<1> {
  type multiple_arguments_initialization_helper (line 102) | struct multiple_arguments_initialization_helper {
  type multiple_arguments_initialization_helper<ArgCount, 0, CorrectT, IncorrectT, Args...> (line 108) | struct multiple_arguments_initialization_helper<ArgCount, 0, CorrectT, I...
  type multiple_arguments_initialization_helper<0, IncorrectArgIndex, CorrectT, IncorrectT, Args...> (line 115) | struct multiple_arguments_initialization_helper<0, IncorrectArgIndex, Co...
  type incorrect_arg_index_iteration_helper (line 123) | struct incorrect_arg_index_iteration_helper {
  type incorrect_arg_index_iteration_helper<ArgCount, CurrentIncorrectIndex, CorrectT, IncorrectT> (line 131) | struct incorrect_arg_index_iteration_helper<ArgCount, CurrentIncorrectIn...
  type arg_count_iteration_helper (line 138) | struct arg_count_iteration_helper {
  type arg_count_iteration_helper<MAX_TUPLE_TEST_SIZE, CorrectT, IncorrectT> (line 145) | struct arg_count_iteration_helper<MAX_TUPLE_TEST_SIZE, CorrectT, Incorre...
  type join_node_correct_initialization_helper (line 154) | struct join_node_correct_initialization_helper {
  type join_node_correct_initialization_helper<0, CorrectT, Args...> (line 159) | struct join_node_correct_initialization_helper<0, CorrectT, Args...> {
  type arg_count_correct_initialization_helper (line 164) | struct arg_count_correct_initialization_helper {
  type arg_count_correct_initialization_helper<MAX_TUPLE_TEST_SIZE, CorrectT> (line 170) | struct arg_count_correct_initialization_helper<MAX_TUPLE_TEST_SIZE, Corr...

FILE: third-party/tbb/test/tbb/test_join_node_msg_key_matching.cpp
  type message_key (line 28) | struct message_key {
    method key (line 32) | int key() const { return my_key; }
  function test_deduction_guides (line 39) | void test_deduction_guides() {

FILE: third-party/tbb/test/tbb/test_join_node_preview.cpp
  function jn_follows_and_precedes (line 31) | void jn_follows_and_precedes() {
  function jn_msg_key_matching_follows_and_precedes (line 65) | void jn_msg_key_matching_follows_and_precedes() {
  function test_follows_and_precedes_api (line 80) | void test_follows_and_precedes_api() {
  function test_try_put_and_wait_queueing (line 85) | void test_try_put_and_wait_queueing() {
  function test_try_put_and_wait_reserving (line 154) | void test_try_put_and_wait_reserving() {
  type int_wrapper (line 230) | struct int_wrapper {
    method int_wrapper (line 232) | int_wrapper() : i(0) {}
    method int_wrapper (line 233) | int_wrapper(int ii) : i(ii) {}
    method int_wrapper (line 234) | int_wrapper& operator=(int ii) {
    method key (line 239) | int key() const {
  function test_try_put_and_wait_key_matching (line 249) | void test_try_put_and_wait_key_matching(Body... body) {

FILE: third-party/tbb/test/tbb/test_limiter_node.cpp
  type serial_receiver (line 45) | struct serial_receiver : public tbb::flow::receiver<T>, utils::NoAssign {
    method serial_receiver (line 49) | serial_receiver(tbb::flow::graph& g) : next_value(T(0)), my_graph(g) {}
    method graph_task (line 51) | graph_task* try_put_task( const T &v ) override {
    method graph_task (line 57) | graph_task * try_put_task( const T &v, const tbb::detail::d2::message_...
  type parallel_receiver (line 68) | struct parallel_receiver : public tbb::flow::receiver<T>, utils::NoAssign {
    method parallel_receiver (line 73) | parallel_receiver(tbb::flow::graph& g) : my_graph(g) { my_count = 0; }
    method graph_task (line 75) | graph_task* try_put_task( const T &/*v*/ ) override {
    method graph_task (line 81) | graph_task * try_put_task( const T &v, const tbb::detail::d2::message_...
  type empty_sender (line 92) | struct empty_sender : public tbb::flow::sender<T> {
    method register_successor (line 95) | bool register_successor( successor_type & ) override { return false; }
    method remove_successor (line 96) | bool remove_successor( successor_type & ) override { return false; }
  type put_body (line 101) | struct put_body : utils::NoAssign {
    method put_body (line 106) | put_body( tbb::flow::limiter_node<T> &lim, std::atomic<int> &accept_co...
  type put_dec_body (line 119) | struct put_dec_body : utils::NoAssign {
    method put_dec_body (line 124) | put_dec_body( tbb::flow::limiter_node<T> &lim, std::atomic<int> &accep...
  function test_puts_with_decrements (line 142) | void test_puts_with_decrements( int num_threads, tbb::flow::limiter_node...
  function test_parallel (line 165) | int test_parallel(int num_threads) {
  function test_serial (line 201) | int test_serial() {
  type mfnode_body (line 248) | struct mfnode_body {
    method mfnode_body (line 251) | mfnode_body(const int& _max, std::atomic<int> &_my) : max_cnt(_max), m...
  type fn_body (line 271) | struct fn_body {
  function test_multifunction_to_limiter (line 288) | void
  function test_continue_msg_reception (line 324) | void
  function test_reserve_release_messages (line 343) | void test_reserve_release_messages() {
  function test_decrementer (line 387) | void test_decrementer() {
  function test_try_put_without_successors (line 449) | void test_try_put_without_successors() {
  function test_follows_and_precedes_api (line 486) | void test_follows_and_precedes_api() {
  function test_deduction_guides (line 501) | void test_deduction_guides() {
  function test_decrement_while_try_put_task (line 521) | void test_decrement_while_try_put_task() {
  function test_try_put_and_wait (line 550) | void test_try_put_and_wait() {
  type TestLargeStruct (line 679) | struct TestLargeStruct {

FILE: third-party/tbb/test/tbb/test_multifunction_node.cpp
  function buffered_levels (line 54) | void buffered_levels( size_t concurrency, Body body ) {
  type inc_functor (line 135) | struct inc_functor {
    method inc_functor (line 138) | inc_functor( ) { local_execute_count = 0; }
    method inc_functor (line 139) | inc_functor( const inc_functor &f ) { local_execute_count = size_t(f.l...
  function buffered_levels_with_copy (line 151) | void buffered_levels_with_copy( size_t concurrency ) {
  function run_buffered_levels (line 219) | void run_buffered_levels( int c ) {
  function concurrency_levels (line 238) | void concurrency_levels( size_t concurrency, Body body ) {
  function run_concurrency_levels (line 317) | void run_concurrency_levels( int c ) {
  type empty_no_assign (line 325) | struct empty_no_assign {
    method empty_no_assign (line 326) | empty_no_assign() {}
    method empty_no_assign (line 327) | empty_no_assign( int ) {}
  type parallel_puts (line 333) | struct parallel_puts : private utils::NoAssign {
    method parallel_puts (line 337) | parallel_puts( tbb::flow::receiver< InputType > &exe_node ) : my_exe_n...
  function unlimited_concurrency (line 357) | void unlimited_concurrency( Body body ) {
  function run_unlimited_concurrency (line 395) | void run_unlimited_concurrency() {
  type oddEvenBody (line 404) | struct oddEvenBody {
  function run_multiport_test (line 419) | void run_multiport_test(int num_threads) {
  function test_concurrency (line 453) | void test_concurrency(int num_threads) {
  function test_ports_return_references (line 473) | void test_ports_return_references() {
  function test_precedes (line 487) | void test_precedes() {
  function test_follows_and_precedes_api (line 514) | void test_follows_and_precedes_api() {
  type InputObject (line 590) | struct InputObject {
    method InputObject (line 591) | InputObject() = default;
    method InputObject (line 592) | InputObject( const InputObject& ) = default;

FILE: third-party/tbb/test/tbb/test_mutex.cpp
  function IsInsideTx (line 39) | inline static bool IsInsideTx() {
  function have_TSX (line 43) | bool have_TSX() {
  type AddOne_CheckTransaction (line 73) | struct AddOne_CheckTransaction {
    method AddOne_CheckTransaction (line 75) | AddOne_CheckTransaction& operator=(const AddOne_CheckTransaction&) = d...
    method AddOne_CheckTransaction (line 76) | AddOne_CheckTransaction(const AddOne_CheckTransaction&) = default;
    method AddOne_CheckTransaction (line 77) | AddOne_CheckTransaction() = default;
    method AddOne_CheckTransaction (line 93) | AddOne_CheckTransaction(C& counter_) : counter(counter_) {}
  function TestTransaction (line 98) | void TestTransaction(const char* name)

FILE: third-party/tbb/test/tbb/test_mutex.h
  function namespace (line 27) | namespace test_with_native_threads {

FILE: third-party/tbb/test/tbb/test_numa_dist.cpp
  type numa (line 58) | struct numa {
    method numa (line 62) | numa() : processorGroupCount(GetMaximumProcessorGroupCount()), maxProc...
  function TestNumaDistribution (line 71) | int TestNumaDistribution(std::vector<DWORD> &validateProcgrp, int additi...

FILE: third-party/tbb/test/tbb/test_openmp.cpp
  function SerialConvolve (line 37) | void SerialConvolve( data_type c[], const data_type a[], int m, const da...
  class InnerBody (line 54) | class InnerBody: utils::NoAssign {
    method InnerBody (line 60) | InnerBody( data_type /*c*/[], const data_type a[], const data_type b[]...
    method InnerBody (line 63) | InnerBody( InnerBody& x, tbb::split ) :
    method join (line 67) | void join( InnerBody& x ) { sum += x.sum; }
  function OpenMP_TBB_Convolve (line 79) | void OpenMP_TBB_Convolve( data_type c[], const data_type a[], int m, con...
  class OuterBody (line 94) | class OuterBody: utils::NoAssign {
    method OuterBody (line 109) | OuterBody( data_type c[], const data_type a[], int m_, const data_type...
  function TBB_OpenMP_Convolve (line 126) | void TBB_OpenMP_Convolve( data_type c[], const data_type a[], int m, con...
  function TestNumThreads (line 131) | void TestNumThreads() {
  function RunTest (line 150) | void RunTest( Func F, int m, int n, int p) {

FILE: third-party/tbb/test/tbb/test_overwrite_node.cpp
  function simple_read_write_tests (line 38) | void simple_read_write_tests() {
  class native_body (line 91) | class native_body : utils::NoAssign {
    method native_body (line 96) | native_body( tbb::flow::overwrite_node<R> &n ) : my_node(n) {}
  function parallel_read_write_tests (line 106) | void parallel_read_write_tests() {
  function test_follows_and_precedes_api (line 155) | void test_follows_and_precedes_api() {
  function test_deduction_guides (line 167) | void test_deduction_guides() {
  function test_overwrite_node_try_put_and_wait (line 188) | void test_overwrite_node_try_put_and_wait() {

FILE: third-party/tbb/test/tbb/test_parallel_for.cpp
  type SSE_Functor (line 56) | struct SSE_Functor {
    method SSE_Functor (line 58) | SSE_Functor( ClassWithVectorType* src, ClassWithVectorType* dst ) : Sr...
  function TestVectorTypes (line 68) | void TestVectorTypes() {
  type TestSimplePartitionerStabilityFunctor (line 84) | struct TestSimplePartitionerStabilityFunctor {
    method TestSimplePartitionerStabilityFunctor (line 86) | TestSimplePartitionerStabilityFunctor(std::vector<int> & theRanges):ra...
  function TestSimplePartitionerStability (line 91) | void TestSimplePartitionerStability(){
  type various_range_implementations (line 111) | namespace various_range_implementations {
    class Body (line 117) | class Body {
      method Body (line 120) | Body(utils::SpinBarrier& sb) : m_sb(sb) { }
      method Body (line 121) | Body(Body& b, tbb::split) : m_sb(b.m_sb) { }
    type correctness (line 130) | namespace correctness {
      function test (line 134) | void test() {
    type uniform_distribution (line 142) | namespace uniform_distribution {
      function test (line 146) | void test() {
    function test (line 158) | void test() {
  type test_cancellation (line 192) | namespace test_cancellation {
    type FunctorToCancel (line 194) | struct FunctorToCancel {
      method reset (line 209) | static void reset() { need_to_wait = true; }
    class ParallelForRunner (line 218) | class ParallelForRunner {
      method run_parallel_for (line 225) | void run_parallel_for( Args&&... args ) const {
      method run_overload (line 231) | void run_overload( Args&&... args ) const {
      method ParallelForRunner (line 258) | ParallelForRunner( tbb::task_group_context& ctx )
    function run_parallel_for_cancellation_test (line 279) | void run_parallel_for_cancellation_test() {
    type ParallelForTestRunner (line 290) | struct ParallelForTestRunner {
      method run (line 291) | static void run() {
    type ParallelForTestRunner<maxParallelForRunnerMode> (line 298) | struct ParallelForTestRunner<maxParallelForRunnerMode> {
      method run (line 299) | static void run() {
  function test_pfor_range_constraints (line 336) | void test_pfor_range_constraints() {
  function test_pfor_body_constraints (line 351) | void test_pfor_body_constraints() {
  function test_pfor_func_constraints (line 363) | void test_pfor_func_constraints() {
  function test_pfor_index_constraints (line 373) | void test_pfor_index_constraints() {

FILE: third-party/tbb/test/tbb/test_parallel_for_each.cpp
  type cpp20_iterator (line 33) | struct cpp20_iterator {
    method cpp20_iterator (line 42) | cpp20_iterator() = default;
    method cpp20_iterator (line 43) | explicit cpp20_iterator(T* ptr) : my_ptr(ptr) {}
    method T (line 45) | T& operator*() const { return *my_ptr; }
    method cpp20_iterator (line 47) | cpp20_iterator& operator++() {
    method cpp20_iterator (line 52) | cpp20_iterator operator++(int) {
    method cpp20_iterator (line 58) | cpp20_iterator& operator--()
    method cpp20_iterator (line 65) | cpp20_iterator operator--(int)
    method cpp20_iterator (line 73) | cpp20_iterator& operator+=(difference_type n)
    method cpp20_iterator (line 80) | cpp20_iterator& operator-=(difference_type n)
    method T (line 87) | T& operator[](difference_type n) const
    method cpp20_iterator (line 98) | cpp20_iterator operator+(cpp20_iterator i, difference_type n)
    method cpp20_iterator (line 104) | cpp20_iterator operator+(difference_type n, cpp20_iterator i)
    method cpp20_iterator (line 110) | cpp20_iterator operator-(cpp20_iterator i, difference_type n)
    method difference_type (line 116) | difference_type operator-(const cpp20_iterator& x, const cpp20_iterato...
  function test_pfor_each_iterator_constraints (line 239) | void test_pfor_each_iterator_constraints() {
  function test_pfor_each_container_based_sequence_constraints (line 246) | void test_pfor_each_container_based_sequence_constraints() {
  function test_pfor_each_body_constraints (line 253) | void test_pfor_each_body_constraints() {
  type no_copy_move (line 273) | struct no_copy_move {
    method no_copy_move (line 274) | no_copy_move() = default;
    method no_copy_move (line 276) | no_copy_move(const no_copy_move&) = delete;
    method no_copy_move (line 277) | no_copy_move(no_copy_move&&) = delete;
    method no_copy_move (line 279) | no_copy_move& operator=(const no_copy_move&) = delete;
    method no_copy_move (line 280) | no_copy_move& operator=(no_copy_move&&) = delete;
  function test_with_cpp20_iterator (line 286) | void test_with_cpp20_iterator() {

FILE: third-party/tbb/test/tbb/test_parallel_invoke.cpp
  function test_from_2_to_10_arguments (line 64) | void test_from_2_to_10_arguments(const Body& body, const std::atomic<std...
  function func (line 89) | void func() { func_counter++; }

FILE: third-party/tbb/test/tbb/test_parallel_phase.cpp
  function active_wait_for (line 31) | void active_wait_for(std::chrono::microseconds duration) {
  type dummy_func (line 40) | struct dummy_func {
  function measure_median_start_time (line 46) | std::size_t measure_median_start_time(tbb::task_arena* ta, const F1& sta...
  class start_time_collection_base (line 92) | class start_time_collection_base {
    method start_time_collection_base (line 95) | start_time_collection_base(tbb::task_arena& ta, std::size_t ntrials) :
    method start_time_collection_base (line 98) | explicit start_time_collection_base(std::size_t ntrials) :
    method measure (line 101) | std::vector<std::size_t> measure() {
  class start_time_collection (line 114) | class start_time_collection : public start_time_collection_base<start_ti...
    method measure_impl (line 119) | std::size_t measure_impl() {
  class start_time_collection_phase_wrapped (line 124) | class start_time_collection_phase_wrapped
    method measure_impl (line 131) | std::size_t measure_impl() {
  class start_time_collection_scoped_phase_wrapped (line 139) | class start_time_collection_scoped_phase_wrapped
    method measure_impl (line 146) | std::size_t measure_impl() {
  class start_time_collection_sequenced_phases (line 153) | class start_time_collection_sequenced_phases
    method measure_impl (line 161) | std::size_t measure_impl() {
    method start_time_collection_sequenced_phases (line 200) | start_time_collection_sequenced_phases(tbb::task_arena& ta, std::size_...
    method start_time_collection_sequenced_phases (line 204) | explicit start_time_collection_sequenced_phases(std::size_t ntrials, b...
  class start_time_collection_sequenced_scoped_phases (line 209) | class start_time_collection_sequenced_scoped_phases
    method measure_impl (line 217) | std::size_t measure_impl() {
    method start_time_collection_sequenced_scoped_phases (line 240) | start_time_collection_sequenced_scoped_phases(tbb::task_arena& ta, std...
    method start_time_collection_sequenced_scoped_phases (line 244) | explicit start_time_collection_sequenced_scoped_phases(std::size_t ntr...

FILE: third-party/tbb/test/tbb/test_parallel_pipeline.cpp
  function freeBuffer (line 67) | void freeBuffer(void *buf) {
  class free_on_scope_exit (line 78) | class free_on_scope_exit {
    method free_on_scope_exit (line 80) | free_on_scope_exit(T *p) : my_p(p) {}
  function middle_is_ready (line 88) | bool middle_is_ready(T &/*p*/) { return false; }
  function middle_is_ready (line 91) | bool middle_is_ready(CheckType<U> &p) { return p.is_ready(); }
  function output_is_ready (line 94) | bool output_is_ready(T &/*p*/) { return true; }
  function output_is_ready (line 97) | bool output_is_ready(CheckType<U> &p) { return p.is_ready(); }
  function middle_my_id (line 100) | int middle_my_id( T &/*p*/) { return 0; }
  function middle_my_id (line 103) | int middle_my_id(CheckType<U> &p) { return p.id(); }
  function output_my_id (line 106) | int output_my_id( T &/*p*/) { return 1; }
  function output_my_id (line 109) | int output_my_id(CheckType<U> &p) { return p.id(); }
  function my_function (line 112) | void my_function(T &p) { p = 0; }
  function my_function (line 115) | void my_function(CheckType<U> &p) { p.get_ready(); }
  class input_filter (line 119) | class input_filter : DestroyedTracker {
    method U (line 121) | U operator()( tbb::flow_control& control ) const {
  class input_filter<U*> (line 135) | class input_filter<U*> : DestroyedTracker {
    method U (line 137) | U* operator()(tbb::flow_control& control) const {
  class input_filter<void> (line 158) | class input_filter<void> : DestroyedTracker {
  class input_filter<int> (line 173) | class input_filter<int> : DestroyedTracker {
  class middle_filter (line 189) | class middle_filter : DestroyedTracker {
    method U (line 191) | U operator()(T t) const {
  class middle_filter<T*,U> (line 203) | class middle_filter<T*,U> : DestroyedTracker {
    method U (line 205) | U operator()(T* my_storage) const {
  class middle_filter<T,U*> (line 220) | class middle_filter<T,U*> : DestroyedTracker {
    method U (line 222) | U* operator()(T my_storage) const {
  class middle_filter<T*,U*> (line 235) | class middle_filter<T*,U*> : DestroyedTracker {
    method U (line 237) | U* operator()(T* my_storage) const {
  class middle_filter<int,int> (line 257) | class middle_filter<int,int> : DestroyedTracker {
  class output_filter (line 268) | class output_filter : DestroyedTracker {
  class output_filter<int> (line 281) | class output_filter<int> : DestroyedTracker {
  class output_filter<T*> (line 292) | class output_filter<T*> : DestroyedTracker {
  function resetCounters (line 314) | void resetCounters() {
  function checkCounters (line 327) | void checkCounters(final_assert_type my_t) {
  function fill_chain (line 384) | void fill_chain( filter_chain &my_chain, mode_array *filter_type, input_...
  function run_function_spec (line 392) | void run_function_spec(Context&... context) {
  function run_filter_set (line 418) | void run_filter_set(
  function run_lambdas_test (line 503) | void run_lambdas_test( mode_array *filter_type, Context&... context ) {
  function run_function (line 592) | void run_function(const char *l1, const char *l2) {

FILE: third-party/tbb/test/tbb/test_parallel_reduce.cpp
  type Sum (line 35) | struct Sum {
    method T (line 37) | T operator() ( const T& v1, const T& v2 ) const {
  type Accumulator (line 42) | struct Accumulator {
    method ValueType (line 43) | ValueType operator() ( const tbb::blocked_range<ValueType*>& r, ValueT...
  class ParallelSumTester (line 50) | class ParallelSumTester {
    method ParallelSumTester (line 52) | ParallelSumTester( const ParallelSumTester& ) = default;
    method ParallelSumTester (line 55) | ParallelSumTester() : m_range(nullptr, nullptr) {
    method CheckParallelReduce (line 64) | void CheckParallelReduce() {
  type test_cancellation (line 88) | namespace test_cancellation {
    type ReduceToCancel (line 90) | struct ReduceToCancel {
    type JoinToCancel (line 98) | struct JoinToCancel {
    type ReduceFunctorToCancel (line 106) | struct ReduceFunctorToCancel {
      method ReduceFunctorToCancel (line 109) | ReduceFunctorToCancel() : result(0) {}
      method ReduceFunctorToCancel (line 110) | ReduceFunctorToCancel( ReduceFunctorToCancel&, tbb::split ) : result...
      method join (line 116) | void join( ReduceFunctorToCancel& rhs ) {
    class ParallelReduceRunner (line 125) | class ParallelReduceRunner {
      method run_parallel_reduce (line 131) | void run_parallel_reduce( Args&&... args ) const {
      method ParallelReduceRunner (line 158) | ParallelReduceRunner( tbb::task_group_context& ctx )
    class ParallelDeterministicReduceRunner (line 176) | class ParallelDeterministicReduceRunner {
      method run_parallel_deterministic_reduce (line 182) | void run_parallel_deterministic_reduce( Args&&... args ) const {
      method ParallelDeterministicReduceRunner (line 200) | ParallelDeterministicReduceRunner( tbb::task_group_context& ctx )
    function run_parallel_reduce_cancellation_test (line 215) | void run_parallel_reduce_cancellation_test() {
    function run_parallel_deterministic_reduce_cancellation_test (line 226) | void run_parallel_deterministic_reduce_cancellation_test() {
    type ParallelReduceTestRunner (line 237) | struct ParallelReduceTestRunner {
      method run (line 238) | static void run() {
    type ParallelReduceTestRunner<maxParallelReduceRunnerMode> (line 245) | struct ParallelReduceTestRunner<maxParallelReduceRunnerMode> {
      method run (line 246) | static void run() {
    type ParallelDeterministicReduceTestRunner (line 252) | struct ParallelDeterministicReduceTestRunner {
      method run (line 253) | static void run() {
    type ParallelDeterministicReduceTestRunner<maxParallelDeterministicReduceRunnerMode> (line 260) | struct ParallelDeterministicReduceTestRunner<maxParallelDeterministicR...
      method run (line 261) | static void run() {
  function test_preduce_range_constraints (line 322) | void test_preduce_range_constraints() {
  function test_preduce_body_constraints (line 347) | void test_preduce_body_constraints() {
  function test_preduce_func_constraints (line 358) | void test_preduce_func_constraints() {
  function test_preduce_combine_constraints (line 368) | void test_preduce_combine_constraints() {
  function test_pdet_reduce_range_constraints (line 378) | void test_pdet_reduce_range_constraints() {
  function test_pdet_reduce_body_constraints (line 403) | void test_pdet_reduce_body_constraints() {
  function test_pdet_reduce_func_constraints (line 414) | void test_pdet_reduce_func_constraints() {
  function test_pdet_reduce_combine_constraints (line 424) | void test_pdet_reduce_combine_constraints() {
  class MinimalRange (line 450) | class MinimalRange {
    method MinimalRange (line 453) | explicit MinimalRange( size_t i ) : begin(0), end(i) {}
    method MinimalRange (line 456) | MinimalRange( MinimalRange& r, tbb::split ) : end(r.end) {
    method is_divisible (line 459) | bool is_divisible() const {return end-begin>=2;}
    method empty (line 460) | bool empty() const {return begin==end;}
  class FooBody (line 464) | class FooBody {
    method FooBody (line 479) | FooBody() {++FooBodyCount;}
    method FooBody (line 486) | FooBody( FooBody& other, tbb::split ) {
    method init (line 495) | void init() {
    method join (line 504) | void join( FooBody& s ) {
  function TestSplitting (line 526) | void TestSplitting( std::size_t nthread ) {
  type unsupported (line 562) | namespace unsupported {
    function parallel_deterministic_reduce (line 564) | void parallel_deterministic_reduce(const Range&, Body&, const tbb::aut...
    function parallel_deterministic_reduce (line 566) | void parallel_deterministic_reduce(const Range&, Body&, tbb::affinity_...
    function Value (line 569) | Value parallel_deterministic_reduce(const Range& , const Value& identi...
    function Value (line 573) | Value parallel_deterministic_reduce(const Range& , const Value& identi...
  type Body (line 578) | struct Body {
    method Body (line 580) | Body() : value(0) {}
    method Body (line 581) | Body(Body&, tbb::split) { value = 0; }
    method join (line 583) | void join(Body&) {}

FILE: third-party/tbb/test/tbb/test_parallel_scan.cpp
  function TriangularSum (line 42) | inline int TriangularSum( int i ) {
  function VerifySum (line 48) | void VerifySum( int init, long finish_index, int sum, int line ) {
  type AddendFlag (line 55) | enum AddendFlag {
  type Storage (line 68) | struct Storage {
    method Storage (line 71) | Storage(T init) :
    method Storage (line 78) | Storage(const Storage& strg) :
    method Storage (line 82) | Storage & operator=(const Storage& strg) {
  function JoinStorages (line 90) | Storage<T> JoinStorages(const Storage<T>& left, const Storage<T>& right) {
  function Scan (line 101) | void Scan(const Range & r, bool is_final, Storage<T> & storage, std::vec...
  function ScanWithInit (line 123) | Storage<T> ScanWithInit(const Range & r, T init, bool is_final, Storage<...
  class Accumulator (line 131) | class Accumulator {
    type state_type (line 135) | enum state_type {
    method Accumulator (line 161) | Accumulator( T init, const std::vector<T> & array, std::vector<T> & su...
    method Accumulator (line 171) | Accumulator( Accumulator& a, tbb::split ) :
    method reverse_join (line 191) | void reverse_join( const Accumulator& left_body) {
    method assign (line 202) | void assign( const Accumulator& other ) {
    method T (line 212) | T get_total() {
  function T (line 219) | T ParallelScanFunctionalInvoker(const Range& range, T idx, const Scan& s...
  class ScanBody (line 233) | class ScanBody {
    method ScanBody (line 239) | ScanBody(T init, const std::vector<T> &addend, std::vector<T> &sum) :m...
  class JoinBody (line 246) | class JoinBody {
  type ParallelScanTemplateFunctor (line 254) | struct ParallelScanTemplateFunctor {
    method T (line 256) | T operator()(Range range, T init, const std::vector<T> &addend, std::v...
  type ParallelScanLambda (line 271) | struct ParallelScanLambda {
    method T (line 273) | T operator()(Range range, T init, const std::vector<T> &addend, std::v...
  function TestAccumulator (line 293) | void TestAccumulator( int mode ) {
  function TestInterface (line 349) | void TestInterface( int mode, ParallelScanWrapper parallel_scan_wrapper ) {
  type ParallelScanGenericLambda (line 374) | struct ParallelScanGenericLambda {
    method T (line 376) | T operator()(Range range, T init, const std::vector<T> &addend, std::v...
  function test_pscan_range_constraints (line 424) | void test_pscan_range_constraints() {
  function test_pscan_body_constraints (line 449) | void test_pscan_body_constraints() {
  function test_pscan_func_constraints (line 465) | void test_pscan_func_constraints() {
  function test_pscan_combine_constraints (line 475) | void test_pscan_combine_constraints() {

FILE: third-party/tbb/test/tbb/test_parallel_sort.cpp
  class Minimal (line 41) | class Minimal {
    method set_val (line 44) | void set_val(int i) { val = i; }
    method Less (line 45) | static bool Less (const Minimal &a, const Minimal &b) {
    method AreEqual (line 48) | static bool AreEqual( const Minimal &a, const Minimal &b) {
  class MinimalLessCompare (line 54) | class MinimalLessCompare {
  function compare (line 62) | bool compare(const Value& lhs, const Value& rhs) {
  function compare (line 66) | bool compare(const Minimal& lhs, const Minimal& rhs) {
  function validate (line 71) | void validate(Range test_range, Range sorted_range) {
  function set (line 90) | void set(RefType& ref, ValueType new_value) {
  function set (line 95) | void set(Minimal& minimal_ref, ValueType new_value) {
  function set (line 100) | void set(std::string& string_ref, KeyType key) {
  function fill_ranges (line 106) | bool fill_ranges(RandomAccessIterator test_range_begin, RandomAccessIter...
  type parallel_sort_test (line 153) | struct parallel_sort_test {
    method run (line 154) | static void run() {
    method run (line 166) | static void run(Comparator& comp) {
  function parallel_sort_test_suite (line 178) | void parallel_sort_test_suite() {
  function parallel_sort_test_suite (line 191) | void parallel_sort_test_suite() {
  function test_psort_iterator_constraints (line 226) | void test_psort_iterator_constraints() {
  function test_psort_compare_constraints (line 247) | void test_psort_compare_constraints() {
  function test_psort_cbs_constraints (line 265) | void test_psort_cbs_constraints() {
  type minimal_span (line 295) | struct minimal_span {
    method minimal_span (line 296) | minimal_span(T* input_data, std::size_t input_size)
    method T (line 301) | T* begin() const {
    method T (line 304) | T* end() const {
  function sort_array_test (line 357) | void sort_array_test(const SortFunctor& sort_functor) {

FILE: third-party/tbb/test/tbb/test_partitioner.cpp
  type task_affinity_retention (line 38) | namespace task_affinity_retention {
    class leaving_observer (line 40) | class leaving_observer : public tbb::task_scheduler_observer {
      method leaving_observer (line 43) | leaving_observer(tbb::task_arena& a) : tbb::task_scheduler_observer(...
      method on_scheduler_entry (line 47) | void on_scheduler_entry(bool) override {
      method on_scheduler_exit (line 51) | void on_scheduler_exit(bool) override {
      method wait_leave (line 55) | void wait_leave() {
    function test (line 62) | float test(PerBodyFunc&& body) {
    function relaxed_test (line 153) | void relaxed_test() {
    function strict_test (line 163) | void strict_test() {
  function test_custom_range (line 182) | void test_custom_range(int diff_mult) {
  class custom_range (line 207) | class custom_range : public oneapi::tbb::blocked_range<int> {
    method custom_range (line 210) | custom_range(int l, int r, int g) : base_type(l, r, g) {}
    method custom_range (line 211) | custom_range(const custom_range& r) : base_type(r) {}
    method custom_range (line 213) | custom_range(custom_range& r, tbb::split) : base_type(r, tbb::split()) {}
  class custom_range_with_psplit (line 218) | class custom_range_with_psplit : public oneapi::tbb::blocked_range<int> {
    method custom_range_with_psplit (line 221) | custom_range_with_psplit(int l, int r, int g) : base_type(l, r, g) {}
    method custom_range_with_psplit (line 222) | custom_range_with_psplit(const custom_range_with_psplit& r) : base_typ...
    method custom_range_with_psplit (line 224) | custom_range_with_psplit(custom_range_with_psplit& r, tbb::split) : ba...
    method custom_range_with_psplit (line 225) | custom_range_with_psplit(custom_range_with_psplit& r, tbb::proportiona...

FILE: third-party/tbb/test/tbb/test_partitioner.h
  function namespace (line 26) | namespace test_partitioner_utils {
  function round (line 138) | size_t round(T part) { return size_t(part); }
  function T (line 139) | T compute_right_part(RangeBase& r, proportional_split& p) {
  function is_ensure_non_emptiness (line 142) | bool is_ensure_non_emptiness() { return m_ensure_non_empty_size; }
  function namespace (line 145) | namespace TestRanges {
  type TreeNode (line 276) | struct TreeNode {
  function class (line 299) | class BinaryTree {
  function compare_nodes (line 417) | bool compare_nodes(TreeNode* node1, TreeNode* node2) const {
  function fill_leafs_impl (line 424) | void fill_leafs_impl(TreeNode* node, std::vector<TreeNode*>& leafs) const {
  function class (line 432) | class SimpleBody {
  function class (line 494) | class Range6: public SplitConstructorAssertedRange {

FILE: third-party/tbb/test/tbb/test_priority_queue_node.cpp
  function spin_try_get (line 43) | void spin_try_get( tbb::flow::priority_queue_node<T> &q, T &value ) {
  function check_item (line 48) | void check_item( T* next_value, T &value ) {
  type parallel_puts (line 56) | struct parallel_puts : utils::NoAssign {
    method parallel_puts (line 58) | parallel_puts( tbb::flow::priority_queue_node<T> &q ) : my_q(q) {}
  type parallel_gets (line 68) | struct parallel_gets : utils::NoAssign {
    method parallel_gets (line 70) | parallel_gets( tbb::flow::priority_queue_node<T> &q) : my_q(q) {}
  type parallel_put_get (line 83) | struct parallel_put_get : utils::NoAssign {
    method parallel_put_get (line 85) | parallel_put_get( tbb::flow::priority_queue_node<T> &q ) : my_q(q) {}
  function test_reservation (line 108) | int test_reservation(int) {
  function test_parallel (line 168) | int test_parallel(int num_threads) {
  function test_serial (line 246) | int test_serial() {
  function test_follows_and_precedes_api (line 344) | void test_follows_and_precedes_api() {
  function test_deduction_guides (line 354) | void test_deduction_guides() {
  function test_pqueue_node_try_put_and_wait (line 383) | void test_pqueue_node_try_put_and_wait() {

FILE: third-party/tbb/test/tbb/test_profiling.cpp
  type Body (line 61) | struct Body {
  type async_body (line 73) | struct async_body
  type mf_body (line 181) | struct mf_body
  type seq_inspector (line 219) | struct seq_inspector {

FILE: third-party/tbb/test/tbb/test_queue_node.cpp
  function spin_try_get (line 43) | void spin_try_get( tbb::flow::queue_node<T> &q, T &value ) {
  function check_item (line 59) | void check_item( T* next_value, T &value ) {
  type parallel_puts (line 67) | struct parallel_puts : utils::NoAssign {
    method parallel_puts (line 71) | parallel_puts( tbb::flow::queue_node<T> &q ) : my_q(q) {}
  type touches (line 83) | struct touches {
    method touches (line 89) | touches( int num_threads ) : my_num_threads(num_threads) {
    method check (line 112) | bool check( int tid, T v ) {
    method validate_touches (line 127) | bool validate_touches() {
  type parallel_gets (line 152) | struct parallel_gets : utils::NoAssign {
    method parallel_gets (line 157) | parallel_gets( tbb::flow::queue_node<T> &q, touches<T> &t) : my_q(q), ...
  type parallel_put_get (line 170) | struct parallel_put_get : utils::NoAssign {
    method parallel_put_get (line 175) | parallel_put_get( tbb::flow::queue_node<T> &q, touches<T> &t ) : my_q(...
  function test_reservation (line 202) | int test_reservation() {
  function test_parallel (line 253) | int test_parallel(int num_threads) {
  function test_serial (line 358) | int test_serial() {
  function test_follows_and_precedes_api (line 468) | void test_follows_and_precedes_api() {
  function test_deduction_guides (line 478) | void test_deduction_guides() {
  function test_queue_node_try_put_and_wait (line 499) | void test_queue_node_try_put_and_wait() {

FILE: third-party/tbb/test/tbb/test_resumable_tasks.cpp
  class AsyncActivity (line 41) | class AsyncActivity {
    method AsyncActivity (line 43) | AsyncActivity(int num_) : m_numAsyncThreads(num_) {
    method submit (line 62) | void submit(tbb::task::suspend_point ctx) {
    method asyncLoop (line 69) | static void asyncLoop(AsyncActivity* async) {
  type SuspendBody (line 92) | struct SuspendBody {
    method SuspendBody (line 93) | SuspendBody(AsyncActivity& a_, std::thread::id id) :
  class InnermostArenaBody (line 105) | class InnermostArenaBody {
    method InnermostArenaBody (line 107) | InnermostArenaBody(AsyncActivity& a_) : m_asyncActivity(a_) {}
    type InnermostInnerParFor (line 115) | struct InnermostInnerParFor {
      method InnermostInnerParFor (line 116) | InnermostInnerParFor(AsyncActivity& a_) : m_asyncActivity(a_) {}
    type InnermostOuterParFor (line 122) | struct InnermostOuterParFor {
      method InnermostOuterParFor (line 123) | InnermostOuterParFor(AsyncActivity& a_) : m_asyncActivity(a_) {}
  class OutermostArenaBody (line 136) | class OutermostArenaBody {
    method OutermostArenaBody (line 138) | OutermostArenaBody(AsyncActivity& a_, tbb::task_arena& o_, tbb::task_a...
  function TestNestedArena (line 171) | void TestNestedArena() {
  class EpochAsyncActivity (line 189) | class EpochAsyncActivity {
    method EpochAsyncActivity (line 191) | EpochAsyncActivity(int num_, std::atomic<int>& e_) : m_numAsyncThreads...
    method submit (line 210) | void submit(tbb::task::suspend_point ctx) {
    method asyncLoop (line 217) | static void asyncLoop(EpochAsyncActivity* async) {
  type EpochSuspendBody (line 243) | struct EpochSuspendBody {
    method EpochSuspendBody (line 244) | EpochSuspendBody(EpochAsyncActivity& a_, std::atomic<int>& e_, int& le...
  function TestSuspendResume (line 259) | void TestSuspendResume() {
  function TestCleanupMaster (line 302) | void TestCleanupMaster() {
  class ParForSuspendBody (line 331) | class ParForSuspendBody {
    method ParForSuspendBody (line 335) | ParForSuspendBody(AsyncActivity& a_, int iters) : asyncActivity(a_), m...
  function TestNativeThread (line 342) | void TestNativeThread() {
  class ObserverTracker (line 365) | class ObserverTracker : public tbb::task_scheduler_observer {
    method ObserverTracker (line 370) | ObserverTracker(tbb::task_arena& a) : tbb::task_scheduler_observer(a) {
    method on_scheduler_entry (line 374) | void on_scheduler_entry(bool) override {
    method on_scheduler_exit (line 380) | void on_scheduler_exit(bool) override {
  function TestObservers (line 389) | void TestObservers() {
  class TestCaseGuard (line 406) | class TestCaseGuard {
    method TestCaseGuard (line 411) | TestCaseGuard()

FILE: third-party/tbb/test/tbb/test_scheduler_mix.cpp
  class Random (line 43) | class Random {
    type State (line 44) | struct State {
      method State (line 49) | State() : gen(rd()), dist(0, std::numeric_limits<unsigned short>::ma...
      method get (line 51) | int get() {
    method get (line 64) | int get() {
  function aligned_free (line 90) | void aligned_free(void* ptr) {
  class PtrRWMutex (line 99) | class PtrRWMutex {
    method T (line 108) | T* pointer() {
    method state (line 112) | std::uintptr_t state() {
    class ScopedLock (line 117) | class ScopedLock {
      method ScopedLock (line 119) | constexpr ScopedLock() : mMutex(nullptr), mIsWriter(false) {}
      method ScopedLock (line 121) | ScopedLock(PtrRWMutex& m, bool write = true) : mMutex(nullptr) {
      method ScopedLock (line 132) | ScopedLock(const ScopedLock&) = delete;
      method ScopedLock (line 133) | ScopedLock& operator=(const ScopedLock&) = delete;
      method acquire (line 136) | void acquire(PtrRWMutex& m) {
      method tryAcquire (line 144) | bool tryAcquire(PtrRWMutex& m, bool write = true) {
      method clear (line 153) | void clear() {
      method release (line 162) | void release() {
    method trySet (line 179) | bool trySet(T* ptr) {
    method clear (line 191) | void clear() {
    method tryLock (line 196) | bool tryLock() {
    method tryLockShared (line 210) | bool tryLockShared() {
    method lock (line 224) | void lock() {
    method unlock (line 232) | void unlock() {
    method unlockShared (line 238) | void unlockShared() {
    method T (line 249) | T* get() {
  class Statistics (line 254) | class Statistics {
    type ACTION (line 256) | enum ACTION {
    type StatType (line 271) | struct StatType {
      method StatType (line 272) | StatType() : mCounters() {}
    method StatType (line 279) | StatType& get() {
      method StatType (line 272) | StatType() : mCounters() {}
    method notify (line 294) | void notify(ACTION a) {
    method report (line 298) | void report() {
  class LifetimeTracker (line 323) | class LifetimeTracker {
    method LifetimeTracker (line 325) | LifetimeTracker() = default;
    class Guard (line 327) | class Guard {
      method Guard (line 329) | Guard(LifetimeTracker* obj) {
      method Guard (line 339) | Guard(Guard&& ing) : mObj(ing.mObj) {
      method continue_execution (line 349) | bool continue_execution() {
    method Guard (line 357) | Guard makeGuard() {
      method Guard (line 329) | Guard(LifetimeTracker* obj) {
      method Guard (line 339) | Guard(Guard&& ing) : mObj(ing.mObj) {
      method continue_execution (line 349) | bool continue_execution() {
    method signalShutdown (line 361) | void signalShutdown() {
    method waitCompletion (line 365) | void waitCompletion() {
  class ArenaTable (line 376) | class ArenaTable {
    type ThreadState (line 384) | struct ThreadState {
    method find_arena (line 394) | auto find_arena(std::size_t start, F f) -> decltype(f(std::declval<Are...
    method create (line 407) | void create(Random& rnd) {
    method destroy (line 431) | void destroy(Random& rnd) {
    method shutdown (line 454) | void shutdown() {
    method acquire (line 469) | std::pair<tbb::task_arena*, std::size_t> acquire(Random& rnd, ScopedLo...
    method release (line 495) | void release(ScopedLock& lock) {
  type ACTIONS (line 510) | enum ACTIONS {
  type actor (line 528) | struct actor
  type actor<arena_create> (line 531) | struct actor<arena_create> {
    method do_it (line 532) | static void do_it(Random& r) {
  type actor<arena_destroy> (line 538) | struct actor<arena_destroy> {
    method do_it (line 539) | static void do_it(Random& r) {
  type actor<arena_action> (line 545) | struct actor<arena_action> {
    method do_it (line 546) | static void do_it(Random& r, size_t arenaAfterStealing) {
  type actor<parallel_algorithm> (line 600) | struct actor<parallel_algorithm> {
    method do_it (line 601) | static void do_it(Random& rnd) {
  function global_actor (line 633) | void global_actor(size_t arenaAfterStealing) {

FILE: third-party/tbb/test/tbb/test_semaphore.cpp
  class Body (line 42) | class Body : utils::NoAssign {
    method Body (line 51) | Body( int nThread, int nIter, semaphore& sem,
  function test_semaphore (line 81) | void test_semaphore( int sem_init_cnt, int extra_threads ) {
  type Counter (line 110) | struct Counter {
    method Counter (line 113) | Counter() : value(0) {}
  type AddOne (line 118) | struct AddOne : utils::NoAssign {
    method AddOne (line 130) | AddOne( C& c ) : my_counter(c) {
  function test_binary_semaphore (line 135) | void test_binary_semaphore( int n_threads ) {
  type FilterType (line 144) | enum FilterType { imaProducer, imaConsumer }
  class FilterBase (line 146) | class FilterBase : utils::NoAssign {
    method FilterBase (line 161) | FilterBase( FilterType filter,
  class ProduceConsumeBody (line 188) | class ProduceConsumeBody {
    method ProduceConsumeBody (line 191) | ProduceConsumeBody( FilterBase** filters ) : my_filters(filters) {}
  function test_producer_consumer (line 253) | void test_producer_consumer( unsigned totTokens, unsigned nTokens, unsig...

FILE: third-party/tbb/test/tbb/test_sequencer_node.cpp
  type seq_inspector (line 41) | struct seq_inspector {
  function wait_try_get (line 46) | bool wait_try_get( tbb::flow::graph &g, tbb::flow::sequencer_node<T> &q,...
  function spin_try_get (line 52) | void spin_try_get( tbb::flow::queue_node<T> &q, T &value ) {
  type parallel_puts (line 57) | struct parallel_puts : utils::NoAssign {
    method parallel_puts (line 62) | parallel_puts( tbb::flow::sequencer_node<T> &q, int num_threads ) : my...
  type touches (line 74) | struct touches {
    method touches (line 80) | touches( int num_threads ) : my_num_threads(num_threads) {
    method check (line 99) | bool check( int tid, T v ) {
    method validate_touches (line 113) | bool validate_touches() {
  type parallel_gets (line 138) | struct parallel_gets : utils::NoAssign {
    method parallel_gets (line 144) | parallel_gets( tbb::flow::sequencer_node<T> &q, int num_threads, touch...
  type parallel_put_get (line 157) | struct parallel_put_get : utils::NoAssign {
    method parallel_put_get (line 165) | parallel_put_get( tbb::flow::sequencer_node<T> &s1, tbb::flow::sequenc...
  function test_parallel (line 196) | int test_parallel(int num_threads) {
  function test_serial (line 263) | int test_serial() {
  function test_follows_and_precedes_api (line 399) | void test_follows_and_precedes_api() {
  function test_deduction_guides_common (line 415) | void test_deduction_guides_common(Body body) {
  function sequencer_body_f (line 432) | std::size_t sequencer_body_f(const int&) { return 1; }
  function test_deduction_guides (line 434) | void test_deduction_guides() {
  function test_seq_node_try_put_and_wait (line 442) | void test_seq_node_try_put_and_wait() {
  type Object (line 638) | struct Object : test_concepts::Copyable, test_concepts::CopyAssignable {}

FILE: third-party/tbb/test/tbb/test_split_node.cpp
  class name_of (line 46) | class name_of {
  class name_of<int> (line 51) | class name_of<int> {
  class name_of<float> (line 56) | class name_of<float> {
  class name_of<double> (line 61) | class name_of<double> {
  class name_of<long> (line 66) | class name_of<long> {
  class name_of<short> (line 71) | class name_of<short> {
  type tuple_helper (line 84) | struct tuple_helper {
    method set_element (line 86) | static void set_element( TupleType &t, int i) {
  type tuple_helper<1> (line 93) | struct tuple_helper<1> {
    method set_element (line 95) | static void set_element(TupleType &t, int i) {
  class my_input_body (line 103) | class my_input_body {
    method my_input_body (line 109) | my_input_body(int init_val, int addto) : my_count(init_val), addend(ad...
    method TT (line 110) | TT operator()( tbb::flow_control &fc) {
  class makeSplit (line 125) | class makeSplit {
    method SType (line 127) | static SType *create(tbb::flow::graph& g) {
    method destroy (line 131) | static void destroy(SType *p) { delete p; }
  class sink_node_helper (line 140) | class sink_node_helper {
    method print_parallel_remark (line 145) | static void print_parallel_remark() {
    method print_serial_remark (line 149) | static void print_serial_remark() {
    method add_sink_nodes (line 153) | static void add_sink_nodes(SType &my_split, tbb::flow::graph &g) {
    method check_sink_values (line 160) | static void check_sink_values() {
    method remove_sink_nodes (line 173) | static void remove_sink_nodes(SType& my_split) {
  class sink_node_helper<1, SType> (line 182) | class sink_node_helper<1, SType> {
    method print_parallel_remark (line 187) | static void print_parallel_remark() {
    method print_serial_remark (line 190) | static void print_serial_remark() {
    method add_sink_nodes (line 193) | static void add_sink_nodes(SType &my_split, tbb::flow::graph &g) {
    method check_sink_values (line 198) | static void check_sink_values() {
    method remove_sink_nodes (line 210) | static void remove_sink_nodes(SType& my_split) {
  class parallel_test (line 220) | class parallel_test {
    method test (line 226) | static void test() {
  function test_one_serial (line 270) | void test_one_serial( SType &my_split, tbb::flow::graph &g) {
  function test_follows_and_precedes_api (line 297) | void test_follows_and_precedes_api() {
  class serial_test (line 337) | class serial_test {
    method test (line 342) | static void test() {
  type generate_test (line 367) | struct generate_test {
    method do_test (line 369) | static void do_test() {
  function test_deduction_guides (line 376) | void test_deduction_guides() {
  function test_try_put_and_wait (line 401) | void test_try_put_and_wait() {

FILE: third-party/tbb/test/tbb/test_tagged_msg.cpp
  function TestWrapper (line 56) | void TestWrapper() {
  function RunTests (line 113) | void RunTests() {

FILE: third-party/tbb/test/tbb/test_task.cpp
  type EmptyBody (line 37) | struct EmptyBody {
  class CountingTask (line 48) | class CountingTask : public tbb::detail::d1::task {
    method CountingTask (line 50) | CountingTask( Body body, tbb::detail::d1::wait_context& wait ) : my_bo...
    method CountingTask (line 52) | CountingTask( tbb::detail::d1::wait_context& wait ) : my_wait(wait) {}
    method task (line 54) | task* execute( tbb::detail::d1::execution_data& ) override {
    method task (line 61) | task* cancel( tbb::detail::d1::execution_data& ) override {
    method reset (line 67) | static void reset() {
    method execute_counter (line 72) | static std::size_t execute_counter() { return my_execute_counter; }
    method cancel_counter (line 73) | static std::size_t cancel_counter() { return my_cancel_counter; }
  function test_cancellation_on_exception (line 95) | void test_cancellation_on_exception( bool reset_ctx ) {
  class SpawningTaskBody (line 297) | class SpawningTaskBody
    method SpawningTaskBody (line 305) | SpawningTaskBody( task_pool_type& task_pool, tbb::task_group_context& ...
  class SpawningTaskBody (line 301) | class SpawningTaskBody {
    method SpawningTaskBody (line 305) | SpawningTaskBody( task_pool_type& task_pool, tbb::task_group_context& ...
  type suspended_task (line 348) | struct suspended_task : public tbb::detail::d1::task {
    method suspended_task (line 350) | suspended_task(tbb::task::suspend_point tag, tbb::detail::d1::wait_con...
    method task (line 354) | task* execute(tbb::detail::d1::execution_data&) override {
    method task (line 371) | task* cancel(tbb::detail::d1::execution_data&) override {
  type bypass_task (line 417) | struct bypass_task : public tbb::detail::d1::task {
    method bypass_task (line 420) | bypass_task(tbb::detail::d1::wait_context& wait, task_pool_type& task_...
    method task (line 425) | task* execute(tbb::detail::d1::execution_data&) override {
    method task (line 450) | task* cancel(tbb::detail::d1::execution_data&) override {
  type resubmitting_task (line 726) | struct resubmitting_task : public tbb::detail::d1::task {
    method resubmitting_task (line 731) | resubmitting_task(tbb::task_arena& arena, tbb::task_group_context& ctx...

FILE: third-party/tbb/test/tbb/test_task_arena.cpp
  function InitializeAndTerminate (line 53) | void InitializeAndTerminate( int maxthread ) {
  function ResetTLS (line 104) | void ResetTLS() {
  class ArenaObserver (line 110) | class ArenaObserver : public tbb::task_scheduler_observer {
    method on_scheduler_entry (line 114) | void on_scheduler_entry( bool is_worker ) override {
    method on_scheduler_exit (line 126) | void on_scheduler_exit( bool /*is_worker*/ ) override {
    method ArenaObserver (line 134) | ArenaObserver(tbb::task_arena &a, int maxConcurrency, int numReservedS...
  type IndexTrackingBody (line 148) | struct IndexTrackingBody { // Must be used together with ArenaObserver
  type AsynchronousWork (line 155) | struct AsynchronousWork {
    method AsynchronousWork (line 158) | AsynchronousWork(utils::SpinBarrier &a_barrier, bool blocking = true)
  function TestConcurrentArenasFunc (line 172) | void TestConcurrentArenasFunc(int idx) {
  function TestConcurrentArenas (line 218) | void TestConcurrentArenas(int p) {
  class MultipleMastersPart1 (line 225) | class MultipleMastersPart1 : utils::NoAssign {
    method MultipleMastersPart1 (line 229) | MultipleMastersPart1( tbb::task_arena &a, utils::SpinBarrier &b1, util...
  class MultipleMastersPart2 (line 239) | class MultipleMastersPart2 : utils::NoAssign {
    method MultipleMastersPart2 (line 243) | MultipleMastersPart2( tbb::task_arena &a, utils::SpinBarrier &b) : my_...
  class MultipleMastersPart3 (line 249) | class MultipleMastersPart3 : utils::NoAssign {
    type Runner (line 254) | struct Runner : NoAssign {
      method Runner (line 256) | Runner(wait_context& w) : myWait(w) {}
    type Waiter (line 263) | struct Waiter : NoAssign {
      method Waiter (line 265) | Waiter(wait_context& w) : myWait(w) {}
    method MultipleMastersPart3 (line 273) | MultipleMastersPart3(tbb::task_arena &a, utils::SpinBarrier &b)
  function TestMultipleMasters (line 287) | void TestMultipleMasters(int p) {
  type TestArenaEntryBody (line 325) | struct TestArenaEntryBody : FPModeContext {
    method TestArenaEntryBody (line 331) | TestArenaEntryBody(std::atomic<int> &s, int idx, int i)  // init threa...
    method on_exception (line 361) | void on_exception(const char *e) { // outside arena, in catch block
    method after_execute (line 366) | void after_execute() { // outside arena and catch block
  class ForEachArenaEntryBody (line 372) | class ForEachArenaEntryBody : utils::NoAssign {
    method ForEachArenaEntryBody (line 378) | ForEachArenaEntryBody(tbb::task_arena &a, std::atomic<int> &c)
    method test (line 381) | void test(int idx) {
    method test_arena_entry (line 402) | void test_arena_entry(int i) const {
  function TestArenaEntryConsistency (line 419) | void TestArenaEntryConsistency() {
  class TestArenaConcurrencyBody (line 433) | class TestArenaConcurrencyBody : utils::NoAssign {
    method TestArenaConcurrencyBody (line 440) | TestArenaConcurrencyBody( tbb::task_arena &a, int max_concurrency, int...
  function TestArenaConcurrency (line 471) | void TestArenaConcurrency( int p, int reserved = 0, int step = 1) {
  type TestMandatoryConcurrencyObserver (line 510) | struct TestMandatoryConcurrencyObserver : public tbb::task_scheduler_obs...
    method TestMandatoryConcurrencyObserver (line 513) | TestMandatoryConcurrencyObserver(tbb::task_arena& a, utils::SpinBarrie...
    method on_scheduler_exit (line 520) | void on_scheduler_exit(bool worker) override {
  function TestMandatoryConcurrency (line 527) | void TestMandatoryConcurrency() {
  function TestConcurrentFunctionality (line 560) | void TestConcurrentFunctionality(int min_thread_num = 1, int max_thread_...
  type TaskArenaValidator (line 574) | struct TaskArenaValidator {
    method TaskArenaValidator (line 577) | TaskArenaValidator( const tbb::task_arena& other )
    method concurrency (line 582) | int concurrency() { return my_arena.debug_max_concurrency(); }
    method reserved_for_masters (line 583) | int reserved_for_masters() { return my_arena.debug_reserved_slots(); }
  function ValidateAttachedArena (line 593) | void ValidateAttachedArena( tbb::task_arena& arena, bool expect_activated,
  type TestAttachBody (line 614) | struct TestAttachBody : utils::NoAssign {
    method TestAttachBody (line 617) | TestAttachBody( int max_thr ) : maxthread(max_thr) {}
  function TestAttach (line 664) | void TestAttach( int maxthread ) {
  type TestFunctor (line 675) | struct TestFunctor {
  function TestConstantFunctorRequirement (line 680) | void TestConstantFunctorRequirement() {
  type TestIsolatedExecuteNS (line 692) | namespace TestIsolatedExecuteNS {
    class NestedParFor (line 694) | class NestedParFor : utils::NoAssign {
      method NestedParFor (line 696) | NestedParFor() {}
    class ParForBody (line 704) | class ParForBody : utils::NoAssign {
      method ParForBody (line 709) | ParForBody( bool outer_isolation, tbb::enumerable_thread_specific<in...
    class OuterParFor (line 723) | class OuterParFor : utils::NoAssign {
      method OuterParFor (line 727) | OuterParFor( bool outer_isolation, std::atomic<bool> &is_stolen ) : ...
    function TwoLoopsTest (line 736) | void TwoLoopsTest( bool outer_isolation ) {
    function TwoLoopsTest (line 757) | void TwoLoopsTest( bool outer_isolation ) {
    function TwoLoopsTest (line 764) | void TwoLoopsTest() {
    class HeavyMixTestBody (line 769) | class HeavyMixTestBody : utils::NoAssign {
      method RunTwoBodies (line 775) | static void RunTwoBodies( utils::FastRandom<>& rnd, const Body &body...
      class IsolatedBody (line 787) | class IsolatedBody : utils::NoAssign {
        method IsolatedBody (line 791) | IsolatedBody( const HeavyMixTestBody &body, Partitioner &partition...
      method RunNextLevel (line 802) | void RunNextLevel( utils::FastRandom<>& rnd, int &isolated_level ) c...
      method HeavyMixTestBody (line 822) | HeavyMixTestBody( tbb::enumerable_thread_specific<utils::FastRandom<...
    type RandomInitializer (line 843) | struct RandomInitializer {
    function HeavyMixTest (line 849) | void HeavyMixTest() {
    type MyException (line 864) | struct MyException {}
    type IsolatedBodyThrowsException (line 865) | struct IsolatedBodyThrowsException {
    type ExceptionTestBody (line 877) | struct ExceptionTestBody : utils::NoAssign {
      method ExceptionTestBody (line 880) | ExceptionTestBody( tbb::enumerable_thread_specific<int>& ets, std::a...
    function ExceptionTest (line 901) | void ExceptionTest() {
    type NonConstBody (line 914) | struct NonConstBody {
    function TestNonConstBody (line 921) | void TestNonConstBody() {
    class TestEnqueueTask (line 929) | class TestEnqueueTask : public tbb::detail::d1::task {
      method TestEnqueueTask (line 940) | TestEnqueueTask(tbb::enumerable_thread_specific<bool>& exe, std::ato...
    class TestEnqueueIsolateBody (line 957) | class TestEnqueueIsolateBody : utils::NoCopy {
      method TestEnqueueIsolateBody (line 964) | TestEnqueueIsolateBody(tbb::enumerable_thread_specific<bool>& exe, s...
    function TestEnqueue (line 975) | void TestEnqueue() {
  function TestIsolatedExecute (line 1013) | void TestIsolatedExecute() {
  class TestDelegatedSpawnWaitBody (line 1034) | class TestDelegatedSpawnWaitBody : utils::NoAssign {
    method TestDelegatedSpawnWaitBody (line 1038) | TestDelegatedSpawnWaitBody( tbb::task_arena &a, utils::SpinBarrier &b1...
  function TestDelegatedSpawnWait (line 1058) | void TestDelegatedSpawnWait() {
  class TestMultipleWaitsArenaWait (line 1073) | class TestMultipleWaitsArenaWait : utils::NoAssign {
    method TestMultipleWaitsArenaWait (line 1076) | TestMultipleWaitsArenaWait( int idx, int bunch_size, int num_tasks, st...
  class TestMultipleWaitsThreadBody (line 1098) | class TestMultipleWaitsThreadBody : utils::NoAssign {
    method TestMultipleWaitsThreadBody (line 1101) | TestMultipleWaitsThreadBody( int bunch_size, int num_tasks, tbb::task_...
  function TestMultipleWaits (line 1116) | void TestMultipleWaits( int num_threads, int num_bunches, int bunch_size...
  function TestMultipleWaits (line 1145) | void TestMultipleWaits() {
  function TestSmallStackSize (line 1165) | void TestSmallStackSize() {
  type TestMoveSemanticsNS (line 1178) | namespace TestMoveSemanticsNS {
    type TestFunctor (line 1179) | struct TestFunctor {
    type MoveOnlyFunctor (line 1183) | struct MoveOnlyFunctor : utils::MoveOnly, TestFunctor {
      method MoveOnlyFunctor (line 1184) | MoveOnlyFunctor() : utils::MoveOnly() {}
      method MoveOnlyFunctor (line 1185) | MoveOnlyFunctor(MoveOnlyFunctor&& other) : utils::MoveOnly(std::move...
    type MovePreferableFunctor (line 1188) | struct MovePreferableFunctor : utils::Movable, TestFunctor {
      method MovePreferableFunctor (line 1189) | MovePreferableFunctor() : utils::Movable() {}
      method MovePreferableFunctor (line 1190) | MovePreferableFunctor(MovePreferableFunctor&& other) : utils::Movabl...
      method MovePreferableFunctor (line 1191) | MovePreferableFunctor(const MovePreferableFunctor& other) : utils::M...
    type NoMoveNoCopyFunctor (line 1194) | struct NoMoveNoCopyFunctor : utils::NoCopy, TestFunctor {
      method NoMoveNoCopyFunctor (line 1195) | NoMoveNoCopyFunctor() : utils::NoCopy() {}
    function TestFunctors (line 1201) | void TestFunctors() {
  function TestMoveSemantics (line 1217) | void TestMoveSemantics() {
  type TestReturnValueNS (line 1227) | namespace TestReturnValueNS {
    type noDefaultTag (line 1228) | struct noDefaultTag {}
    class ReturnType (line 1229) | class ReturnType : public StateTrackable<> {
      method ReturnType (line 1233) | ReturnType(noDefaultTag) : StateTrackable<>(0) {}
      method ReturnType (line 1235) | ReturnType(const ReturnType& r) : StateTrackable<>(r), data(r.data) {}
      method ReturnType (line 1236) | ReturnType(ReturnType&& r) : StateTrackable<>(std::move(r)), data(st...
      method fill (line 1238) | void fill() {
      method check (line 1242) | void check() {
    function R (line 1264) | R function() {
    type Functor (line 1275) | struct Functor {
      method R (line 1276) | R operator()() const {
    function TestExecute (line 1287) | void TestExecute(F &f) {
    function TestExecute (line 1294) | void TestExecute(const F &f) {
    function TestIsolate (line 1300) | void TestIsolate(F &f) {
    function TestIsolate (line 1307) | void TestIsolate(const F &f) {
    function Test (line 1313) | void Test() {
  function TestReturnValue (line 1332) | void TestReturnValue() {
  type MyObserver (line 1339) | struct MyObserver: public tbb::task_scheduler_observer {
    method MyObserver (line 1346) | MyObserver(tbb::task_arena& a,
    method on_scheduler_entry (line 1358) | void on_scheduler_entry(bool worker) override {
    method on_scheduler_exit (line 1369) | void on_scheduler_exit(bool worker) override {
  function TestArenaWorkersMigrationWithNumThreads (line 1377) | void TestArenaWorkersMigrationWithNumThreads(int n_threads = 0) {
  function TestArenaWorkersMigration (line 1456) | void TestArenaWorkersMigration() {
  function TestDefaultCreatedWorkersAmount (line 1464) | void TestDefaultCreatedWorkersAmount() {
  function TestAbilityToCreateWorkers (line 1491) | void TestAbilityToCreateWorkers(int thread_num) {
  function TestDefaultWorkersLimit (line 1501) | void TestDefaultWorkersLimit() {
  function ExceptionInExecute (line 1512) | void ExceptionInExecute() {
  class simple_observer (line 1543) | class simple_observer : public tbb::task_scheduler_observer {
    method on_scheduler_entry (line 1548) | void on_scheduler_entry( bool is_worker ) override {
    method on_scheduler_exit (line 1555) | void on_scheduler_exit( bool /*is_worker*/ ) override
    method simple_observer (line 1558) | simple_observer(tbb::task_arena &a, int maxConcurrency, int numReserve...
  type arena_handler (line 1576) | struct arena_handler {
    type arena_status (line 1577) | enum arena_status {
    method arena_handler (line 1590) | arena_handler(tbb::task_arena* ptr) : arena(ptr)
  function StressTestMixFunctionality (line 1599) | void StressTestMixFunctionality() {
  type enqueue_test_helper (line 1750) | struct enqueue_test_helper {
    method enqueue_test_helper (line 1751) | enqueue_test_helper(tbb::task_arena& arena, tbb::enumerable_thread_spe...
    method enqueue_test_helper (line 1755) | enqueue_test_helper(const enqueue_test_helper& ef) : my_arena(ef.my_ar...
  function test_threads_sleep (line 1769) | void test_threads_sleep(int concurrency, int reserved_slots, int num_ext...
  function test_threads_sleep (line 1804) | void test_threads_sleep(int concurrency, int reserved_slots) {
  type throwing_obj (line 1920) | struct throwing_obj {
    method throwing_obj (line 1921) | throwing_obj() {
    method throwing_obj (line 1925) | throwing_obj(const throwing_obj&) = default;

FILE: third-party/tbb/test/tbb/test_task_group.cpp
  type SharingMode (line 43) | enum SharingMode {
  class SharedGroupBodyImpl (line 49) | class SharedGroupBodyImpl : utils::NoCopy, utils::NoAfterlife {
    type TaskFunctor (line 63) | struct TaskFunctor {
    method Spawn (line 76) | void Spawn ( std::uintptr_t numTasks ) {
    method DeleteTaskGroup (line 85) | void DeleteTaskGroup () {
    method Wait (line 90) | void Wait () {
    method SharedGroupBodyImpl (line 115) | SharedGroupBodyImpl ( std::uintptr_t numThreads, std::uintptr_t sharin...
    method Run (line 132) | void Run ( std::uintptr_t idx ) {
  class SharedGroupBody (line 167) | class  SharedGroupBody : utils::NoAssign, utils::NoAfterlife {
    method SharedGroupBody (line 171) | SharedGroupBody ( std::uintptr_t numThreads, std::uintptr_t sharingMod...
    method SharedGroupBody (line 177) | SharedGroupBody ( const SharedGroupBody& src )
  class RunAndWaitSyncronizationTestBody (line 195) | class RunAndWaitSyncronizationTestBody : utils::NoAssign {
    method RunAndWaitSyncronizationTestBody (line 200) | RunAndWaitSyncronizationTestBody(utils::SpinBarrier& barrier, std::ato...
  function TestParallelSpawn (line 221) | void TestParallelSpawn () {
  function TestParallelWait (line 226) | void TestParallelWait () {
  function TestVagabondGroup (line 239) | void TestVagabondGroup () {
  function TestThreadSafety (line 246) | void TestThreadSafety() {
  class FibTaskBase (line 289) | class FibTaskBase : utils::NoAssign, utils::NoAfterlife {
    method FibTaskBase (line 295) | FibTaskBase( std::uintptr_t* y, std::uintptr_t n ) : m_pRes(y), m_Num(...
  class FibTaskAsymmetricTreeWithFunctor (line 309) | class FibTaskAsymmetricTreeWithFunctor : public FibTaskBase<task_group_t...
    method FibTaskAsymmetricTreeWithFunctor (line 311) | FibTaskAsymmetricTreeWithFunctor( std::uintptr_t* y, std::uintptr_t n ...
    method impl (line 312) | virtual void impl() const override {
  class FibTaskSymmetricTreeWithFunctor (line 322) | class FibTaskSymmetricTreeWithFunctor : public FibTaskBase<task_group_ty...
    method FibTaskSymmetricTreeWithFunctor (line 324) | FibTaskSymmetricTreeWithFunctor( std::uintptr_t* y, std::uintptr_t n )...
    method impl (line 325) | virtual void impl() const override {
  function RunFibTask (line 338) | std::uintptr_t RunFibTask(std::uintptr_t n) {
  function RunFibTest (line 345) | void RunFibTest() {
  function FibFunctionNoArgs (line 354) | void FibFunctionNoArgs() {
  function TestFibWithLambdas (line 359) | void TestFibWithLambdas() {
  function TestFibWithFunctor (line 371) | void TestFibWithFunctor() {
  function TestFibWithFunctionPtr (line 377) | void TestFibWithFunctionPtr() {
  function RunFibonacciTests (line 388) | void RunFibonacciTests() {
  class test_exception (line 394) | class test_exception : public std::exception
    method test_exception (line 398) | test_exception ( const char* descr ) : m_strDescription(descr) {}
  class ThrowingTask (line 420) | class ThrowingTask : utils::NoAssign, utils::NoAfterlife {
    method ThrowingTask (line 423) | ThrowingTask( atomic_t& counter ) : m_TaskCount(counter) {}
  function ResetGlobals (line 440) | inline void ResetGlobals ( bool bThrow, bool bRethrow ) {
  function LaunchChildrenWithFunctor (line 449) | void LaunchChildrenWithFunctor () {
  function TestManualCancellationWithFunctor (line 485) | void TestManualCancellationWithFunctor () {
  function TestExceptionHandling1 (line 512) | void TestExceptionHandling1 () {
  function TestExceptionHandling2 (line 528) | void TestExceptionHandling2 () {
  function TestExceptionHandling3 (line 550) | void TestExceptionHandling3() {
  class LaunchChildrenDriver (line 567) | class LaunchChildrenDriver {
    method Launch (line 569) | void Launch(task_group_type& tg) {
    method Finish (line 579) | void Finish() {
  function TestMissingWait (line 587) | void TestMissingWait () {
  function RunCancellationAndExceptionHandlingTests (line 618) | void RunCancellationAndExceptionHandlingTests() {
  function EmptyFunction (line 629) | void EmptyFunction () {}
  type TestFunctor (line 631) | struct TestFunctor {
  function TestConstantFunctorRequirement (line 637) | void TestConstantFunctorRequirement() {
  type TestMoveSemanticsNS (line 645) | namespace TestMoveSemanticsNS {
    type TestFunctor (line 646) | struct TestFunctor {
    type MoveOnlyFunctor (line 650) | struct MoveOnlyFunctor : utils::MoveOnly, TestFunctor {
      method MoveOnlyFunctor (line 651) | MoveOnlyFunctor() : utils::MoveOnly() {}
      method MoveOnlyFunctor (line 652) | MoveOnlyFunctor(MoveOnlyFunctor&& other) : utils::MoveOnly(std::move...
    type MovePreferableFunctor (line 655) | struct MovePreferableFunctor : utils::Movable, TestFunctor {
      method MovePreferableFunctor (line 656) | MovePreferableFunctor() : utils::Movable() {}
      method MovePreferableFunctor (line 657) | MovePreferableFunctor(MovePreferableFunctor&& other) : utils::Movabl...
      method MovePreferableFunctor (line 658) | MovePreferableFunctor(const MovePreferableFunctor& other) : utils::M...
    type NoMoveNoCopyFunctor (line 661) | struct NoMoveNoCopyFunctor : utils::NoCopy, TestFunctor {
      method NoMoveNoCopyFunctor (line 662) | NoMoveNoCopyFunctor() : utils::NoCopy() {}
    function TestBareFunctors (line 669) | void TestBareFunctors() {
  function TestMoveSemantics (line 691) | void TestMoveSemantics() {
  type TestIsolationNS (line 698) | namespace TestIsolationNS {
    class DummyFunctor (line 699) | class DummyFunctor {
      method DummyFunctor (line 701) | DummyFunctor() {}
    class ParForBody (line 708) | class ParForBody {
      method ParForBody (line 713) | ParForBody(
    function CheckIsolation (line 732) | void CheckIsolation(bool isolation_is_expected) {
    function TestIsolation (line 747) | void TestIsolation() {
  function run_deep_stealing (line 907) | void run_deep_stealing(tbb::task_group& tg1, tbb::task_group& tg2, int n...
  type SelfRunner (line 1041) | struct SelfRunner {
  type accept_task_group_context (line 1067) | namespace accept_task_group_context {
    function run_cancellation_use_case (line 1070) | void run_cancellation_use_case(CancelF&& cancel, WaitF&& wait) {
    function test (line 1113) | void test() {

FILE: third-party/tbb/test/tbb/test_tbb_fork.cpp
  function threadTerminated (line 49) | bool threadTerminated(HANDLE h)
  type Data (line 55) | struct Data {
  function SigHandler (line 76) | void SigHandler(int) { }
  class AllocTask (line 80) | class AllocTask {
    method AllocTask (line 98) | AllocTask() {}
  function CallParallelFor (line 101) | void CallParallelFor()
  class RunWorkersBody (line 109) | class RunWorkersBody : utils::NoAssign {
    method RunWorkersBody (line 112) | RunWorkersBody(bool waitWorkers) : wait_workers(waitWorkers) {}
  function TestBlockNonblock (line 125) | void TestBlockNonblock()
  class RunInNativeThread (line 133) | class RunInNativeThread : utils::NoAssign {
    method RunInNativeThread (line 137) | RunInNativeThread(bool blocking_) : blocking(blocking_) {}
  function TestTasksInThread (line 150) | void TestTasksInThread()
  function TestSchedulerMemLeaks (line 165) | void TestSchedulerMemLeaks()
  function TestNestingTSI (line 202) | void TestNestingTSI()
  function TestAutoInit (line 228) | void TestAutoInit()
  function main (line 235) | int main()

FILE: third-party/tbb/test/tbb/test_tbb_header.cpp
  type Body (line 93) | struct Body {
  type Body1 (line 96) | struct Body1 {
  type Body1a (line 99) | struct Body1a { // feeder body for parallel_do
  type Body1b (line 102) | struct Body1b { // binary operator for reduction
  type Body1bc (line 105) | struct Body1bc { // binary operator for comparison
  type Body2 (line 108) | struct Body2 {
    method Body2 (line 109) | Body2 () {}
    method Body2 (line 110) | Body2 ( const Body2&, tbb::split ) {}
    method join (line 112) | void join( const Body2& ) {}
  type Body2a (line 114) | struct Body2a { // for lambda-friendly parallel_reduce
  type Body3 (line 117) | struct Body3 { // for parallel_scan
    method Body3 (line 118) | Body3 () {}
    method Body3 (line 119) | Body3 ( const Body3&, tbb::split ) {}
    method reverse_join (line 122) | void reverse_join( Body3& ) {}
    method assign (line 123) | void assign( const Body3& ) {}
  type Body3a (line 125) | struct Body3a { // for lambda-friednly parallel_scan
  type Msg (line 128) | struct Msg {}
  function TestExceptionClassExports (line 135) | void TestExceptionClassExports ( const E& exc, tbb::detail::exception_id...
  function TestExceptionClassesExports (line 157) | static void TestExceptionClassesExports () {
  function TestPreviewNames (line 174) | static void TestPreviewNames() {

FILE: third-party/tbb/test/tbb/test_write_once_node.cpp
  function simple_read_write_tests (line 38) | void simple_read_write_tests() {
  class native_body (line 110) | class native_body : utils::NoAssign {
    method native_body (line 115) | native_body( tbb::flow::write_once_node<R> &n ) : my_node(n) {}
  function parallel_read_write_tests (line 127) | void parallel_read_write_tests() {
  function test_follows_and_precedes_api (line 178) | void test_follows_and_precedes_api() {
  function test_deduction_guides (line 190) | void test_deduction_guides() {
  function test_try_put_and_wait (line 211) | void test_try_put_and_wait() {

FILE: third-party/tbb/test/tbbmalloc/test_malloc_atexit.cpp
  function exe_isMallocOverloaded (line 41) | bool exe_isMallocOverloaded()
  function free (line 71) | void free(void *ptr)
  function dummyFunction (line 88) | void dummyFunction() {}
  function SigSegv (line 94) | static void SigSegv(int)
  function TestReplacedAllocFunc (line 103) | void TestReplacedAllocFunc()
  function TestReplacedAllocFunc (line 123) | void TestReplacedAllocFunc() { }
  class Foo (line 126) | class Foo {
    method Foo (line 128) | Foo() {
  function main (line 139) | int main() {}

FILE: third-party/tbb/test/tbbmalloc/test_malloc_compliance.cpp
  function limitMem (line 56) | void limitMem( size_t limit )
  function limitMem (line 88) | void limitMem( size_t limit )
  type MemStruct (line 185) | struct MemStruct
    method MemStruct (line 190) | MemStruct() : Pointer(nullptr), Size(0) {}
    method MemStruct (line 191) | MemStruct(void* ptr, UINT sz) : Pointer(ptr), Size(sz) {}
  class CMemTest (line 194) | class CMemTest: utils::NoAssign
    method CMemTest (line 201) | CMemTest(utils::SpinBarrier *barrier, bool isVerbose=false) : limitBar...
  class Limit (line 217) | class Limit {
    method Limit (line 220) | Limit(size_t a_limit) : limit(a_limit) {}
  type RoundRobin (line 229) | struct RoundRobin: utils::NoAssign {
    method RoundRobin (line 233) | RoundRobin( long p, utils::SpinBarrier *limitBarrier, bool verbose ) :
  function choose_random_alignment (line 243) | inline size_t choose_random_alignment() {
  function setSystemAllocs (line 249) | static void setSystemAllocs()
  function ReallocParam (line 276) | void ReallocParam()
  function CheckArgumentsOverflow (line 304) | void CheckArgumentsOverflow()
  function InvariantDataRealloc (line 355) | void InvariantDataRealloc(bool aligned, size_t maxAllocSize, bool checkD...
  function CheckReallocLeak (line 395) | void CheckReallocLeak()
  function NonZero (line 416) | size_t NonZero(void *ptr, size_t size)
  type TestStruct (line 436) | struct TestStruct
  function Tposix_memalign (line 477) | int Tposix_memalign(void **memptr, size_t alignment, size_t size)
  type PtrSize (line 502) | struct PtrSize {
  function cmpAddrs (line 507) | static int cmpAddrs(const void *p1, const void *p2)
  function myMemset (line 613) | void myMemset(void *ptr, int c, size_t n)

FILE: third-party/tbb/test/tbbmalloc/test_malloc_init_shutdown.cpp
  class TestFunc1 (line 39) | class TestFunc1 {
    method TestFunc1 (line 42) | TestFunc1 (utils::SpinBarrier& barr) : my_barr(&barr) {}
  function Test1 (line 50) | void Test1 () {
  class TestFunc2a (line 68) | class TestFunc2a {
    method TestFunc2a (line 71) | TestFunc2a (utils::SpinBarrier& barr) : my_barr(&barr) {}
  class TestFunc2b (line 79) | class TestFunc2b {
    method TestFunc2b (line 83) | TestFunc2b (utils::SpinBarrier& barr, std::thread& t) : my_barr(&barr)...
  function Test2 (line 92) | void Test2() {
  function TestKeyDtor (line 110) | void TestKeyDtor() {}
  function threadDtor (line 116) | void threadDtor(void*) {
  function intersectingObjects (line 128) | inline bool intersectingObjects(const void *p1, const void *p2, size_t n)
  type TestThread (line 133) | struct TestThread: utils::NoAssign {
    method TestThread (line 134) | TestThread(int ) {}
  function TestKeyDtor (line 150) | void TestKeyDtor() {

FILE: third-party/tbb/test/tbbmalloc/test_malloc_lib_unload.cpp
  function anchor (line 49) | int anchor() {
  function scalable_free (line 59) | void scalable_free (void *)
  function safer_scalable_free (line 63) | void safer_scalable_free (void *, void (*)(void*))
  function scalable_posix_memalign (line 82) | int scalable_posix_memalign(void **, size_t, size_t)
  function scalable_aligned_free (line 102) | void scalable_aligned_free(void *)
  function scalable_msize (line 106) | size_t scalable_msize(void *)
  function safer_scalable_msize (line 111) | size_t safer_scalable_msize (void *, size_t (*)(void*))
  function main (line 117) | int main() {}
  type Run (line 148) | struct Run {

FILE: third-party/tbb/test/tbbmalloc/test_malloc_new_handler.cpp
  function customNewHandler (line 37) | void customNewHandler() {
  function allocateWithException (line 43) | bool allocateWithException(size_t big_mem) {
  class AllocLoopBody (line 61) | class AllocLoopBody : utils::NoAssign {

FILE: third-party/tbb/test/tbbmalloc/test_malloc_overload.cpp
  class BackRefIdx (line 136) | class BackRefIdx { // composite index to backreference array
    method BackRefIdx (line 142) | BackRefIdx() : main((uint16_t)-1) {}
    method isInvalid (line 143) | bool isInvalid() { return main == (uint16_t)-1; }
    method isLargeObject (line 144) | bool isLargeObject() const { return largeObj; }
    method getMain (line 145) | uint16_t getMain() const { return main; }
    method getOffset (line 146) | uint16_t getOffset() const { return offset; }
  class MemoryPool (line 152) | class MemoryPool
  class ExtMemoryPool (line 153) | class ExtMemoryPool
  type BlockI (line 155) | struct BlockI {
  type LargeMemoryBlock (line 159) | struct LargeMemoryBlock : public BlockI {
  type LargeObjectHdr (line 174) | struct LargeObjectHdr {
  function scalableMallocCheckSize (line 194) | static void scalableMallocCheckSize(void *object, size_t size)
  function CheckStdFuncOverload (line 215) | void CheckStdFuncOverload(void *(*malloc_p)(size_t), void *(*calloc_p)(s...
  function CheckMemalignFuncOverload (line 231) | void CheckMemalignFuncOverload(void *(*memalign_p)(size_t, size_t),
  function CheckVallocFuncOverload (line 240) | void CheckVallocFuncOverload(void *(*valloc_p)(size_t), void (*free_p)(v...
  function CheckPvalloc (line 248) | void CheckPvalloc(void *(*pvalloc_p)(size_t), void (*free_p)(void*))
  function CheckFreeAligned (line 266) | void CheckFreeAligned() {
  function TestZoneOverload (line 301) | void TestZoneOverload() {
  function TestRuntimeRoutines (line 319) | void TestRuntimeRoutines() {
  type BigStruct (line 326) | struct BigStruct {
  function CheckNewDeleteOverload (line 330) | void CheckNewDeleteOverload() {
  function FuncReplacementInfoCheck (line 360) | void FuncReplacementInfoCheck() {
  type mallinfo (line 459) | struct mallinfo

FILE: third-party/tbb/test/tbbmalloc/test_malloc_overload_disable.cpp
  function CheckWindowsProxyDisablingViaMemSize (line 42) | void CheckWindowsProxyDisablingViaMemSize( size_t ObjectSize ) {

FILE: third-party/tbb/test/tbbmalloc/test_malloc_pools.cpp
  function T (line 36) | static inline T alignUp  (T arg, uintptr_t alignment) {
  type PoolSpace (line 40) | struct PoolSpace: utils::NoCopy {
    method PoolSpace (line 48) | PoolSpace(size_t bufSz = BUF_SIZE) :
  type MallocPoolHeader (line 60) | struct MallocPoolHeader {
  function putMallocMem (line 84) | static int putMallocMem(intptr_t /*pool_id*/, void *ptr, size_t bytes)
  function TestPoolReset (line 95) | void TestPoolReset()
  class SharedPoolRun (line 119) | class SharedPoolRun: utils::NoAssign {
    method init (line 129) | static void init(int num, rml::MemoryPool *pl, void **crThread, void *...
  function TestSharedPool (line 173) | void TestSharedPool()
  function CrossThreadPutMem (line 215) | int CrossThreadPutMem(intptr_t pool_id, void* /*raw_ptr*/, size_t /*raw_...
  class CrossThreadRun (line 221) | class CrossThreadRun: utils::NoAssign {
    method initBarrier (line 227) | static void initBarrier(unsigned thrds) { barrier.initialize(thrds); }
    method init (line 228) | static void init(long num) {
    method destroy (line 234) | static void destroy() {
    method CrossThreadRun (line 241) | CrossThreadRun() {}
  function TestCrossThreadPools (line 280) | void TestCrossThreadPools()
  function TestTooSmallBuffer (line 293) | void TestTooSmallBuffer()
  class FixedPoolHeadBase (line 307) | class FixedPoolHeadBase : utils::NoAssign {
    method FixedPoolHeadBase (line 312) | FixedPoolHeadBase(size_t s) : size(s), used(false) {
  class FixedPoolHead (line 327) | class FixedPoolHead : FixedPoolHeadBase {
    method FixedPoolHead (line 329) | FixedPoolHead() : FixedPoolHeadBase(SIZE) { }
  class FixedPoolUse (line 337) | class FixedPoolUse: utils::NoAssign {
    method FixedPoolUse (line 343) | FixedPoolUse(unsigned threads, rml::MemoryPool *p, size_t sz, int it) :
  class FixedPoolNomem (line 359) | class FixedPoolNomem: utils::NoAssign {
    method FixedPoolNomem (line 363) | FixedPoolNomem(utils::SpinBarrier *b, rml::MemoryPool *p) :
  class FixedPoolSomeMem (line 372) | class FixedPoolSomeMem: utils::NoAssign {
    method FixedPoolSomeMem (line 376) | FixedPoolSomeMem(utils::SpinBarrier *b, rml::MemoryPool *p) :
  function haveEnoughSpace (line 387) | bool haveEnoughSpace(rml::MemoryPool *pool, size_t sz)
  function TestFixedBufferPool (line 396) | void TestFixedBufferPool()
  function putGranMem (line 485) | static int putGranMem(intptr_t /*pool_id*/, void *ptr, size_t bytes)
  function TestPoolGranularity (line 492) | void TestPoolGranularity()
  function putMemFree (line 523) | static int putMemFree(intptr_t /*pool_id*/, void *ptr, size_t /*bytes*/)
  function TestPoolKeepTillDestroy (line 530) | void TestPoolKeepTillDestroy()
  function memEqual (line 578) | static bool memEqual(char *buf, size_t size, int val)
  function TestEntries (line 587) | void TestEntries()
  function CheckPoolLeaks (line 655) | void CheckPoolLeaks(size_t poolsAlwaysAvailable)
  function TestPoolCreation (line 687) | void TestPoolCreation()
  type AllocatedObject (line 715) | struct AllocatedObject {
  class PoolIdentityCheck (line 721) | class PoolIdentityCheck : utils::NoAssign {
    method PoolIdentityCheck (line 725) | PoolIdentityCheck(rml::MemoryPool** p, AllocatedObject** o) : pools(p)...
  function TestPoolDetection (line 748) | void TestPoolDetection()
  function TestLazyBootstrap (line 780) | void TestLazyBootstrap()
  class NoLeakOnDestroyRun (line 793) | class NoLeakOnDestroyRun: utils::NoAssign {
    method NoLeakOnDestroyRun (line 797) | NoLeakOnDestroyRun(rml::MemoryPool *p, utils::SpinBarrier *b) : pool(p...
  function TestNoLeakOnDestroy (line 813) | void TestNoLeakOnDestroy()
  function putMallocMemError (line 826) | static int putMallocMemError(intptr_t /*pool_id*/, void *ptr, size_t bytes)
  function TestDestroyFailed (line 837) | void TestDestroyFailed()
  function TestPoolMSize (line 849) | void TestPoolMSize() {

FILE: third-party/tbb/test/tbbmalloc/test_malloc_pure_c.c
  function MyExit (line 49) | static void MyExit(void) {
  function main (line 55) | int main(void) {

FILE: third-party/tbb/test/tbbmalloc/test_malloc_regression.cpp
  class minimalAllocFree (line 28) | class minimalAllocFree {
  function RunThread (line 39) | void RunThread(const Body& body, const Arg& arg) {
  function TestBootstrapLeak (line 47) | bool TestBootstrapLeak() {
  function TestReallocMsize (line 96) | bool TestReallocMsize(size_t startSz) {
  function TestAlignedMsize (line 120) | void TestAlignedMsize()

FILE: third-party/tbb/test/tbbmalloc/test_malloc_shutdown_hang.cpp
  type GlobalObject (line 30) | struct GlobalObject {
  function allocatorRandomThrashing (line 36) | void allocatorRandomThrashing() {
  function hangOnExitReproducer (line 55) | void hangOnExitReproducer() {
  function processSpawn (line 65) | void processSpawn(const char* self) {
  function processSpawn (line 71) | void processSpawn(const char* self) {
  function processSpawn (line 85) | void processSpawn(const char* /*self*/) {
  function main (line 105) | int main(int argc, char* argv[]) {

FILE: third-party/tbb/test/tbbmalloc/test_malloc_used_by_lib.cpp
  function callDll (line 34) | void callDll()
  function main (line 47) | int main() {}
  class UseDll (line 65) | class UseDll {
    method UseDll (line 68) | UseDll(utils::FunctionAddress runPtr) : run(runPtr) { }
  function LoadThreadsUnload (line 74) | void LoadThreadsUnload()
  type UnloadCallback (line 83) | struct UnloadCallback {
  type RunWithLoad (line 91) | struct RunWithLoad {
  function ThreadsLoadUnload (line 114) | void ThreadsLoadUnload() {

FILE: third-party/tbb/test/tbbmalloc/test_malloc_whitebox.cpp
  type tbbmalloc_whitebox (line 68) | namespace tbbmalloc_whitebox {
  class AllocInfo (line 79) | class AllocInfo {
    method AllocInfo (line 84) | AllocInfo() : p(nullptr), val(0), size(0) {}
    method AllocInfo (line 85) | explicit AllocInfo(int sz) : p((int*)scalable_malloc(sz*sizeof(int))),
    method check (line 91) | void check() const {
    method clear (line 95) | void clear() {
  type ShutdownTest (line 101) | struct ShutdownTest {
  class SimpleBarrier (line 113) | class SimpleBarrier: utils::NoAssign {
    method initBarrier (line 117) | static void initBarrier(unsigned thrds) { barrier.initialize(thrds); }
  class TestLargeObjCache (line 122) | class TestLargeObjCache: public SimpleBarrier {
    method TestLargeObjCache (line 126) | TestLargeObjCache( ) {}
  function TestLargeObjectCache (line 170) | void TestLargeObjectCache()
  class TestStartupAlloc (line 184) | class TestStartupAlloc: public SimpleBarrier {
    type TestBlock (line 185) | struct TestBlock {
    method TestStartupAlloc (line 191) | TestStartupAlloc() {}
  class BackRefWork (line 230) | class BackRefWork: utils::NoAssign {
    type TestBlock (line 231) | struct TestBlock {
      method TestBlock (line 234) | TestBlock(BackRefIdx idx_) : idx(idx_) {}
    method BackRefWork (line 237) | BackRefWork() {}
  class LocalCachesHit (line 258) | class LocalCachesHit: utils::NoAssign {
    method LocalCachesHit (line 264) | LocalCachesHit() {}
  function allocatedBackRefCount (line 279) | static size_t allocatedBackRefCount()
  class TestInvalidBackrefs (line 287) | class TestInvalidBackrefs: public SimpleBarrier {
    method TestInvalidBackrefs (line 298) | TestInvalidBackrefs() {}
  function TestBackRef (line 339) | void TestBackRef() {
  function putMem (line 390) | int putMem(intptr_t /*pool_id*/, void* /*raw_ptr*/, size_t /*raw_bytes*/)
  type MallocPoolHeader (line 395) | struct MallocPoolHeader {
  function putMallocMem (line 412) | int putMallocMem(intptr_t /*pool_id*/, void *ptr, size_t bytes)
  class StressLOCacheWork (line 421) | class StressLOCacheWork: utils::NoAssign {
    method StressLOCacheWork (line 424) | StressLOCacheWork(rml::MemoryPool *mallocPool) : my_mallocPool(mallocP...
  function TestPools (line 436) | void TestPools() {
  function TestObjectRecognition (line 562) | void TestObjectRecognition() {
  class TestBackendWork (line 634) | class TestBackendWork: public SimpleBarrier {
    type TestBlock (line 635) | struct TestBlock {
    method TestBackendWork (line 643) | TestBackendWork(rml::internal::Backend *bknd) : backend(bknd) {}
  function TestBackend (line 662) | void TestBackend()
  function TestBitMask (line 703) | void TestBitMask()
  function getMemSize (line 729) | size_t getMemSize()
  class CheckNotCached (line 734) | class CheckNotCached {
  class RunTestHeapLimit (line 751) | class RunTestHeapLimit: public SimpleBarrier {
  function TestHeapLimit (line 767) | void TestHeapLimit()
  function checkNoHugePages (line 805) | void checkNoHugePages()
  function multiThreadAlloc (line 824) | inline void multiThreadAlloc(size_t alloc_size) {
  function crossThreadDealloc (line 830) | inline void crossThreadDealloc() {
  type TestCleanAllBuffersBody (line 841) | struct TestCleanAllBuffersBody : public SimpleBarrier {
  function TestCleanAllBuffers (line 851) | void TestCleanAllBuffers() {
  type TestCleanThreadBuffersBody (line 877) | struct TestCleanThreadBuffersBody : public SimpleBarrier {
  function TestCleanThreadBuffers (line 901) | void TestCleanThreadBuffers() {
  class CacheBinModel (line 926) | class CacheBinModel {
    method doCleanup (line 940) | void doCleanup() {
    method CacheBinModel (line 962) | CacheBinModel(CacheBinType &_cacheBin, size_t allocSize) : cacheBin(_c...
    method get (line 971) | void get() {
    method putList (line 1004) | void putList( int num ) {
    method check (line 1030) | void check() {
  function LOCModelTester (line 1048) | void LOCModelTester() {
  class TestBootstrap (line 1077) | class TestBootstrap {
    method TestBootstrap (line 1081) | TestBootstrap() : allocating(true) {}
    method saveLmb (line 1094) | void saveLmb( rml::internal::LargeMemoryBlock *lmb ) {
  class TestRandom (line 1101) | class TestRandom {
    method TestRandom (line 1105) | TestRandom() : numOps(100000) {
    method saveLmb (line 1122) | void saveLmb( rml::internal::LargeMemoryBlock *lmb ) {
  class TestCollapsingMallocFree (line 1128) | class TestCollapsingMallocFree : public SimpleBarrier {
    method TestCollapsingMallocFree (line 1133) | TestCollapsingMallocFree( int _num_threads ) : num_threads(_num_thread...
    method check (line 1149) | void check() {
  class TestCollapsingBootstrap (line 1155) | class TestCollapsingBootstrap : public SimpleBarrier {
    class CheckNumAllocs (line 1156) | class CheckNumAllocs {
      method CheckNumAllocs (line 1159) | CheckNumAllocs( int _num_threads ) : num_threads(_num_threads) {}
    method TestCollapsingBootstrap (line 1169) | TestCollapsingBootstrap( int _num_threads ) : num_threads(_num_threads) {
    method check (line 1188) | void check() {
  function LOCCollapsingTester (line 1195) | void LOCCollapsingTester( int num_threads ) {
  function TestLOC (line 1207) | void TestLOC() {
  function TestSlabAlignment (line 1227) | void TestSlabAlignment() {
  function TestTHP (line 1252) | void TestTHP() {
  function getStabilizedMemUsage (line 1319) | inline size_t getStabilizedMemUsage() {
  function TestReallocDecreasing (line 1337) | void TestReallocDecreasing() {
  type FunctionReplacement (line 1391) | namespace FunctionReplacement {
    function LogCleanup (line 1396) | void LogCleanup() {
    function TestEmptyLog (line 1408) | void TestEmptyLog() {
    function TestLogOverload (line 1415) | void TestLogOverload() {
    function TestFalseSearchCase (line 1435) | void TestFalseSearchCase() {
    function TestWrongFunctionInDll (line 1447) | void TestWrongFunctionInDll(){
  function TesFunctionReplacementLog (line 1464) | void TesFunctionReplacementLog() {
  function hocIdxToSizeFormula (line 1480) | inline size_t hocIdxToSizeFormula(int idx) {
  function locIdxToSizeFormula (line 1485) | inline size_t locIdxToSizeFormula(int idx) {
  function TestLOCacheBinsConverterImpl (line 1491) | void TestLOCacheBinsConverterImpl(int idx, size_t checkingSize) {
  function TestLOCacheBinsConverter (line 1498) | void TestLOCacheBinsConverter(){
  type HOThresholdTester (line 1513) | struct HOThresholdTester {
    type CleanupType (line 1523) | enum CleanupType {
    method populateCache (line 1529) | void populateCache() {
    method clean (line 1547) | void clean(bool all) {
    method check (line 1558) | void check(CleanupType type) {
    method cacheBinEmpty (line 1574) | bool cacheBinEmpty(int idx) {
    method objectInCacheBin (line 1577) | bool objectInCacheBin(int idx, size_t size) {
    method sizeInCacheRange (line 1581) | bool sizeInCacheRange(size_t size) {
    method alignedSizeFromIdx (line 1584) | size_t alignedSizeFromIdx(int idx) {
  function TestHugeSizeThresholdImpl (line 1591) | void TestHugeSizeThresholdImpl(LargeObjectCache* loc, size_t hugeSize, b...
  function TestHugeSizeThreshold (line 1613) | void TestHugeSizeThreshold() {

FILE: third-party/tbb/test/tbbmalloc/test_scalable_allocator.cpp
  class MinimalAllocator (line 55) | class MinimalAllocator : cnt_provider_t {
    method MinimalAllocator (line 58) | MinimalAllocator() {
    method MinimalAllocator (line 61) | MinimalAllocator(const MinimalAllocator&s) : cnt_provider_t(s) {
    method deallocate (line 78) | void deallocate(void *p, size_t sz) {
  class NullAllocator (line 85) | class NullAllocator {
    method NullAllocator (line 88) | NullAllocator() { }
    method NullAllocator (line 89) | NullAllocator(const NullAllocator&) { }
    method deallocate (line 92) | void deallocate(void *, size_t) { REQUIRE(false); }
  function TestZeroSpaceMemoryPool (line 95) | void TestZeroSpaceMemoryPool()
  type FixedPool (line 103) | struct FixedPool {
    method FixedPool (line 107) | FixedPool(void *a_buf, size_t a_size) : buf(a_buf), size(a_size), used...
  function TestSmallFixedSizePool (line 123) | void TestSmallFixedSizePool()

FILE: third-party/xxhash/cli/xsum_bench.c
  function clock_t (line 62) | static clock_t XSUM_clockSpan( clock_t start )
  function XSUM_findMaxMem (line 67) | static size_t XSUM_findMaxMem(XSUM_U64 requiredMem)
  type XSUM_U32 (line 106) | typedef XSUM_U32 (*hashFunction)(const void* buffer, size_t bufferSize, ...
  function XSUM_U32 (line 108) | static XSUM_U32 localXXH32(const void* buffer, size_t bufferSize, XSUM_U...
  function XSUM_U32 (line 112) | static XSUM_U32 localXXH32_stream(const void* buffer, size_t bufferSize,...
  function XSUM_U32 (line 120) | static XSUM_U32 localXXH64(const void* buffer, size_t bufferSize, XSUM_U...
  function XSUM_U32 (line 124) | static XSUM_U32 localXXH64_stream(const void* buffer, size_t bufferSize,...
  function XSUM_U32 (line 132) | static XSUM_U32 localXXH3_64b(const void* buffer, size_t bufferSize, XSU...
  function XSUM_U32 (line 137) | static XSUM_U32 localXXH3_64b_seeded(const void* buffer, size_t bufferSi...
  function XSUM_U32 (line 141) | static XSUM_U32 localXXH3_64b_secret(const void* buffer, size_t bufferSi...
  function XSUM_U32 (line 146) | static XSUM_U32 localXXH3_128b(const void* buffer, size_t bufferSize, XS...
  function XSUM_U32 (line 151) | static XSUM_U32 localXXH3_128b_seeded(const void* buffer, size_t bufferS...
  function XSUM_U32 (line 155) | static XSUM_U32 localXXH3_128b_secret(const void* buffer, size_t bufferS...
  function XSUM_U32 (line 160) | static XSUM_U32 localXXH3_stream(const void* buffer, size_t bufferSize, ...
  function XSUM_U32 (line 168) | static XSUM_U32 localXXH3_stream_seeded(const void* buffer, size_t buffe...
  function XSUM_U32 (line 176) | static XSUM_U32 localXXH128_stream(const void* buffer, size_t bufferSize...
  function XSUM_U32 (line 184) | static XSUM_U32 localXXH128_stream_seeded(const void* buffer, size_t buf...
  type hashInfo (line 194) | typedef struct {
  function XSUM_benchHash (line 228) | static void XSUM_benchHash(hashFunction h, const char* hName, int testID,
  function XSUM_benchMem (line 351) | static void XSUM_benchMem(const void* buffer, size_t bufferSize)
  function XSUM_selectBenchedSize (line 375) | static size_t XSUM_selectBenchedSize(const char* fileName)
  function XSUM_benchFiles (line 387) | int XSUM_benchFiles(const char* fileNamesTable[], int nbFiles)
  function XSUM_benchInternal (line 429) | int XSUM_benchInternal(size_t keySize)

FILE: third-party/xxhash/cli/xsum_config.h
  type XSUM_U8 (line 191) | typedef uint8_t  XSUM_U8;
  type XSUM_U32 (line 192) | typedef uint32_t XSUM_U32;
  type XSUM_U64 (line 193) | typedef uint64_t XSUM_U64;
  type XSUM_U8 (line 196) | typedef unsigned char      XSUM_U8;
  type XSUM_U32 (line 198) | typedef unsigned int     XSUM_U32;
  type XSUM_U32 (line 200) | typedef unsigned long    XSUM_U32;
  type XSUM_U64 (line 202) | typedef unsigned long long XSUM_U64;

FILE: third-party/xxhash/cli/xsum_os_specific.c
  type XSUM_stat_t (line 34) | typedef struct __stat64 XSUM_stat_t;
  type mode_t (line 36) | typedef int mode_t;
  type XSUM_stat_t (line 39) | typedef struct stat XSUM_stat_t;
  function XSUM_IS_CONSOLE (line 50) | static int XSUM_IS_CONSOLE(FILE* stdStream)
  function XSUM_IS_CONSOLE (line 86) | static __inline int XSUM_IS_CONSOLE(FILE* stdStream)
  function XSUM_API (line 109) | XSUM_API int XSUM_isConsole(FILE* stream)
  function XSUM_API (line 114) | XSUM_API void XSUM_setBinaryMode(FILE* stream)
  function XSUM_API (line 121) | XSUM_API FILE* XSUM_fopen(const char* filename, const char* mode)
  function XSUM_vfprintf (line 126) | int XSUM_vfprintf(FILE* stream, const char* format, va_list ap)
  function XSUM_stat (line 131) | static int XSUM_stat(const char* infilename, XSUM_stat_t* statbuf)
  function main (line 141) | int main(int argc, const char* argv[])
  function wchar_t (line 170) | static wchar_t* XSUM_widenString(const char* str, int* lenOut)
  function XSUM_API (line 216) | XSUM_API FILE* XSUM_fopen(const char* filename, const char* mode)
  function XSUM_stat (line 234) | static int XSUM_stat(const char* infilename, XSUM_stat_t* statbuf)
  function XSUM_vasprintf (line 258) | static int XSUM_vasprintf(char** strp, const char* format, va_list ap)
  function XSUM_vfprintf (line 305) | int XSUM_vfprintf(FILE *stream, const char *format, va_list ap)
  function XSUM_freeArgv (line 387) | static void XSUM_freeArgv(int argc, char** argv)
  function XSUM_wmain (line 399) | static int XSUM_wmain(int argc, wchar_t* utf16_argv[])
  function wmain (line 439) | int __cdecl wmain(int argc, wchar_t* utf16_argv[])
  type _startupinfo (line 463) | typedef struct {
  function main (line 478) | int main(int ansi_argc, const char* ansi_argv[])
  function XSUM_API (line 502) | XSUM_API int XSUM_isDirectory(const char* filename)
  function XSUM_API (line 517) | XSUM_API XSUM_U64 XSUM_getFileSize(const char* filename)

FILE: third-party/xxhash/cli/xsum_output.c
  function XSUM_log (line 32) | int XSUM_log(const char* format, ...)
  function XSUM_output (line 44) | int XSUM_output(const char* format, ...)
  function XSUM_logVerbose (line 55) | int XSUM_logVerbose(int minLevel, const char* format, ...)

FILE: third-party/xxhash/cli/xsum_sanity_check.c
  function XSUM_API (line 46) | XSUM_API void XSUM_fillTestBuffer(XSUM_U8* buffer, size_t len)
  function XSUM_API (line 66) | XSUM_API void XSUM_sanityCheck(void)
  type XSUM_testdata32_t (line 75) | typedef struct {
  type XSUM_testdata64_t (line 81) | typedef struct {
  type XSUM_testdata128_t (line 87) | typedef struct {
  type XSUM_testdata_sample_t (line 94) | typedef struct {
  function XSUM_checkResult32 (line 227) | static void XSUM_checkResult32(XXH32_hash_t r1, XXH32_hash_t r2)
  function XSUM_checkResult64 (line 240) | static void XSUM_checkResult64(XXH64_hash_t r1, XXH64_hash_t r2)
  function XSUM_checkResult128 (line 254) | static void XSUM_checkResult128(XXH128_hash_t r1, XXH128_hash_t r2)
  function XSUM_testXXH32 (line 270) | static void XSUM_testXXH32(const void* data, const XSUM_testdata32_t* te...
  function XSUM_testXXH64 (line 300) | static void XSUM_testXXH64(const void* data, const XSUM_testdata64_t* te...
  function XSUM_U32 (line 334) | static XSUM_U32 XSUM_rand(void)
  type XXH_errorcode (line 345) | typedef XXH_errorcode (*XSUM_XXH3_update_t)(XXH3_state_t* state, const v...
  function XSUM_XXH3_randomUpdate (line 352) | static void XSUM_XXH3_randomUpdate(XXH3_state_t* state, const void* data,
  function XSUM_testXXH3 (line 365) | static void XSUM_testXXH3(const void* data, const XSUM_testdata64_t* tes...
  function XSUM_testXXH3_withSecret (line 455) | static void XSUM_testXXH3_withSecret(const void* data, const void* secret,
  function XSUM_testXXH128 (line 511) | static void XSUM_testXXH128(const void* data, const XSUM_testdata128_t* ...
  function XSUM_testXXH128_withSecret (line 606) | static void XSUM_testXXH128_withSecret(const void* data, const void* sec...
  function XSUM_testSecretGenerator (line 659) | static void XSUM_testSecretGenerator(const void* customSeed, const XSUM_...
  function XSUM_API (line 688) | XSUM_API void XSUM_sanityCheck(void)

FILE: third-party/xxhash/cli/xxhsum.c
  function XSUM_isLittleEndian (line 60) | static unsigned XSUM_isLittleEndian(void)
  type AlgoSelected (line 80) | typedef enum { algo_xxh32=0, algo_xxh64=1, algo_xxh128=2, algo_xxh3=3 } ...
  type AlgoBitmask (line 83) | typedef enum {
  function XSUM_filenameNeedsEscape (line 108) | static int XSUM_filenameNeedsEscape(const char* filename) {
  function XSUM_lineNeedsUnescape (line 114) | static int XSUM_lineNeedsUnescape(const char* line) {
  function XSUM_printFilename (line 123) | static void XSUM_printFilename(const char* filename, int needsEscape) {
  function XSUM_U32 (line 204) | static XSUM_U32 XSUM_algoBitmask_ComputeAlgoBitmaskFromAlgoSelected(Algo...
  function XSUM_algoBitmask_Accepts (line 209) | static int XSUM_algoBitmask_Accepts(XSUM_U32 algoBitmask, AlgoSelected p...
  function XSUM_display_LittleEndian (line 223) | static void XSUM_display_LittleEndian(const void* ptr, size_t length)
  function XSUM_display_BigEndian (line 231) | static void XSUM_display_BigEndian(const void* ptr, size_t length)
  type Multihash (line 239) | typedef union {
  function Multihash (line 250) | static Multihash
  function XSUM_printLine_BSD_internal (line 321) | static void XSUM_printLine_BSD_internal(const char* filename,
  function XSUM_printLine_BSD_LE (line 340) | static void XSUM_printLine_BSD_LE(const char* filename, const void* cano...
  function XSUM_printLine_BSD (line 345) | static void XSUM_printLine_BSD(const char* filename, const void* canonic...
  function XSUM_displayPrefix (line 350) | static void XSUM_displayPrefix(const AlgoSelected hashType)
  function XSUM_printLine_GNU_internal (line 358) | static void XSUM_printLine_GNU_internal(const char* filename,
  function XSUM_printLine_GNU (line 375) | static void XSUM_printLine_GNU(const char* filename,
  function XSUM_printLine_GNU_LE (line 381) | static void XSUM_printLine_GNU_LE(const char* filename,
  type Display_endianness (line 387) | typedef enum { big_endian, little_endian} Display_endianness;
  type Display_convention (line 389) | typedef enum { display_gnu, display_bsd } Display_convention;
  type LineStatus (line 393) | typedef enum {
  function LineStatus (line 406) | static LineStatus XSUM_hashFile(const char* fileName,
  function XSUM_hashFiles (line 486) | static int XSUM_hashFiles(const char* fnList[], int fnTotal,
  type GetLineResult (line 545) | typedef enum {
  type CanonicalFromStringResult (line 553) | typedef enum {
  type ParseLineResult (line 558) | typedef enum {
  type Canonical (line 563) | typedef union {
  type ParsedLine (line 569) | typedef struct {
  type ParseFileReport (line 575) | typedef struct {
  type ParseFileArg (line 586) | typedef struct {
  function GetLineResult (line 611) | static GetLineResult XSUM_getLine(char** lineBuf, int* lineMax, FILE* in...
  function charToHex (line 670) | static int charToHex(char c)
  function CanonicalFromStringResult (line 691) | static CanonicalFromStringResult XSUM_canonicalFromString(unsigned char*...
  function ParseLineResult (line 732) | static ParseLineResult XSUM_parseLine1(ParsedLine* parsedLine, char* lin...
  function ParseLineResult (line 834) | static ParseLineResult XSUM_parseLine(ParsedLine* parsedLine, char* line...
  function XSUM_parseFile1 (line 847) | static void XSUM_parseFile1(ParseFileArg* XSUM_parseFileArg, int rev)
  function XSUM_checkFile (line 1023) | static int XSUM_checkFile(const char* inFileName,
  function XSUM_checkFiles (line 1120) | static int XSUM_checkFiles(const char* fnList[], int fnTotal,
  function ParseLineResult (line 1150) | static ParseLineResult XSUM_parseGenLine(ParsedLine * parsedLine,
  function XSUM_parseGenFile1 (line 1172) | static void XSUM_parseGenFile1(ParseFileArg* XSUM_parseGenArg,
  function XSUM_generateFile (line 1285) | static int XSUM_generateFile(const char* inFileName,
  function XSUM_generateFiles (line 1364) | static int XSUM_generateFiles(const char* fnList[], int fnTotal,
  function XSUM_usage (line 1392) | static int XSUM_usage(const char* exename)
  function XSUM_usage_advanced (line 1411) | static int XSUM_usage_advanced(const char* exename)
  function XSUM_badusage (line 1433) | static int XSUM_badusage(const char* exename)
  function errorOut (line 1440) | static void errorOut(const char* msg)
  function XSUM_readU32FromCharChecked (line 1461) | static int XSUM_readU32FromCharChecked(const char** stringPtr, XSUM_U32*...
  function XSUM_U32 (line 1494) | static XSUM_U32 XSUM_readU32FromChar(const char** stringPtr) {
  function XSUM_API (line 1503) | XSUM_API int XSUM_main(int argc, const char* argv[])

FILE: third-party/xxhash/fuzz/fuzzer.c
  function LLVMFuzzerTestOneInput (line 5) | int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {

FILE: third-party/xxhash/tests/collisions/allcodecs/dummy.c
  function badsum32 (line 30) | unsigned badsum32(const void* input, size_t len, unsigned seed)

FILE: third-party/xxhash/tests/collisions/hashes.h
  type UniHash (line 38) | typedef union {
  function UniHash (line 43) | UniHash uniHash32(uint64_t v32)
  function UniHash (line 49) | UniHash uniHash64(uint64_t v64)
  function UniHash (line 55) | UniHash uniHash128(XXH128_hash_t v128)
  function UniHash (line 64) | UniHash XXH3_wrapper (const void* data, size_t size)
  function UniHash (line 69) | UniHash XXH128_wrapper (const void* data, size_t size)
  function UniHash (line 74) | UniHash XXH128l_wrapper (const void* data, size_t size)
  function UniHash (line 79) | UniHash XXH128h_wrapper (const void* data, size_t size)
  function UniHash (line 84) | UniHash XXH64_wrapper (const void* data, size_t size)
  function UniHash (line 89) | UniHash XXH32_wrapper (const void* data, size_t size)
  function UniHash (line 98) | UniHash badsum32_wrapper (const void* data, size_t size)
  type UniHash (line 107) | typedef UniHash (*hashfn) (const void* data, size_t size);
  type hashDescription (line 109) | typedef struct {

FILE: third-party/xxhash/tests/collisions/main.c
  type Htype_e (line 68) | typedef enum { ht32, ht64, ht128 } Htype_e;
  function hexRaw (line 74) | static void hexRaw(const void* buffer, size_t size)
  function printHash (line 82) | void printHash(const void* table, size_t n, Htype_e htype)
  function avalanche64 (line 109) | static uint64_t avalanche64(uint64_t h64)
  function randomByte (line 119) | static unsigned char randomByte(uint64_t n)
  type sf_genMode (line 126) | typedef enum { sf_slab5, sf_sparse } sf_genMode;
  type sampleFactory (line 141) | typedef struct {
  function init_sampleFactory (line 149) | static void init_sampleFactory(sampleFactory* sf, uint64_t htotal)
  function sampleFactory (line 163) | static sampleFactory*
  function free_sampleFactory (line 178) | static void free_sampleFactory(sampleFactory* sf)
  function update_sampleFactory (line 185) | static inline void update_sampleFactory(sampleFactory* sf)
  function Cnm (line 215) | static double Cnm(int n, int m)
  function enoughCombos (line 228) | static int enoughCombos(size_t size, uint64_t htotal)
  type sampleFactory (line 242) | typedef struct {
  function init_sampleFactory (line 256) | static void init_sampleFactory(sampleFactory* sf, uint64_t htotal)
  function sampleFactory (line 270) | static sampleFactory*
  function free_sampleFactory (line 286) | static void free_sampleFactory(sampleFactory* sf)
  function flipbit (line 293) | static void flipbit(void* buffer, uint64_t bitID)
  function updateBit (line 301) | static int updateBit(void* buffer, size_t* bitIdx, int level, size_t max)
  function update_sampleFactory (line 320) | static inline void update_sampleFactory(sampleFactory* sf)
  type Filter (line 340) | typedef unsigned char Filter;
  function Filter (line 342) | Filter* create_Filter(int bflog)
  function free_Filter (line 356) | void free_Filter(Filter* bf)
  function Filter_insert (line 370) | inline int Filter_insert(Filter* bf, int bflog, uint64_t hash)
  function Filter_check (line 395) | inline int Filter_check(const Filter* bf, int bflog, uint64_t hash)
  function Filter_insert (line 423) | static inline int Filter_insert(Filter* bf, int bflog, uint64_t hash)
  function Filter (line 458) | static Filter* Filter_reduce(Filter* bf, int bflog)
  function Filter_check (line 476) | static inline int Filter_check(const Filter* bf, int bflog, uint64_t hash)
  function update_indicator (line 505) | void update_indicator(uint64_t v, uint64_t total)
  function power (line 547) | static double power(uint64_t base, int p)
  function estimateNbCollisions (line 557) | static double estimateNbCollisions(uint64_t nbH, int nbBits)
  function highestBitSet (line 562) | static int highestBitSet(uint64_t v)
  function select_nbh (line 579) | uint64_t select_nbh(int nbBits)
  type searchCollisions_results (line 590) | typedef struct {
  type searchCollisions_parameters (line 594) | typedef struct {
  function isEqual (line 609) | static int isEqual(void* hTablePtr, size_t index1, size_t index2, Htype_...
  function isHighEqual (line 623) | static int isHighEqual(void* hTablePtr, size_t index1, size_t index2, Ht...
  function addHashCandidate (line 641) | static void addHashCandidate(void* hTablePtr, UniHash h, Htype_e htype, ...
  function getNbBits_fromHtype (line 651) | static int getNbBits_fromHtype(Htype_e htype) {
  function Htype_e (line 660) | static Htype_e getHtype_fromHbits(int nbBits) {
  function search_collisions (line 669) | static size_t search_collisions(
  function getProcessMemUsage (line 869) | static size_t getProcessMemUsage(int children)
  function getProcessMemUsage (line 878) | static size_t getProcessMemUsage(int ignore) { (void)ignore; return 0; }
  function time_collisions (line 881) | void time_collisions(searchCollisions_parameters param)
  function MT_searchCollisions (line 918) | void MT_searchCollisions(void* payload)
  function readU64FromChar (line 930) | static uint64_t readU64FromChar(const char** stringPtr)
  function longCommandWArg (line 966) | static int longCommandWArg(const char** stringPtr, const char* longCommand)
  function help (line 986) | void help(const char* exeName)
  function bad_argument (line 1005) | int bad_argument(const char* exeName)
  function main (line 1013) | int main(int argc, const char** argv)

FILE: third-party/xxhash/tests/collisions/pool.c
  type POOL_job (line 41) | typedef struct POOL_job_s {
  type POOL_ctx_s (line 46) | struct POOL_ctx_s {
  function POOL_ctx (line 120) | POOL_ctx* POOL_create(size_t numThreads, size_t queueSize)
  function POOL_join (line 164) | static void POOL_join(POOL_ctx* ctx) {
  function POOL_free (line 181) | void POOL_free(POOL_ctx *ctx) {
  function POOL_sizeof (line 194) | size_t POOL_sizeof(POOL_ctx *ctx) {
  function POOL_resize_internal (line 203) | static int POOL_resize_internal(POOL_ctx* ctx, size_t numThreads)
  function POOL_resize (line 232) | int POOL_resize(POOL_ctx* ctx, size_t numThreads)
  function isQueueFull (line 249) | static int isQueueFull(POOL_ctx const* ctx) {
  function POOL_add_internal (line 259) | static void POOL_add_internal(POOL_ctx* ctx, POOL_function function, voi...
  function POOL_add (line 271) | void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque)
  function POOL_tryAdd (line 284) | int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque)
  type POOL_ctx_s (line 306) | struct POOL_ctx_s {
  function POOL_ctx (line 311) | POOL_ctx* POOL_create(size_t numThreads, size_t queueSize) {
  function POOL_free (line 317) | void POOL_free(POOL_ctx* ctx) {
  function POOL_resize (line 322) | int POOL_resize(POOL_ctx* ctx, size_t numThreads) {
  function POOL_add (line 327) | void POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque) {
  function POOL_tryAdd (line 332) | int POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque) {
  function POOL_sizeof (line 338) | size_t POOL_sizeof(POOL_ctx* ctx) {

FILE: third-party/xxhash/tests/collisions/pool.h
  type POOL_ctx (line 21) | typedef struct POOL_ctx_s POOL_ctx;

FILE: third-party/xxhash/tests/collisions/sort.cc
  function sort64 (line 38) | void sort64(uint64_t* table, size_t size)
  function sort128 (line 45) | void sort128(XXH128_hash_t* table, size_t size)

FILE: third-party/xxhash/tests/collisions/threading.c
  function worker (line 43) | static unsigned __stdcall worker(void *arg)
  function ZSTD_pthread_create (line 50) | int ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused,
  function ZSTD_pthread_join (line 64) | int ZSTD_pthread_join(ZSTD_pthread_t thread, void **value_ptr)

FILE: third-party/xxhash/tests/collisions/threading.h
  type ZSTD_pthread_t (line 63) | typedef struct {
  type ZSTD_pthread_mutex_t (line 103) | typedef int ZSTD_pthread_mutex_t;
  type ZSTD_pthread_cond_t (line 109) | typedef int ZSTD_pthread_cond_t;

FILE: third-party/xxhash/tests/generate_unicode_test.c
  function main (line 62) | int main(void)

FILE: third-party/xxhash/tests/multiInclude.c
  function hash_advanced (line 62) | void hash_advanced(void)
  function main (line 75) | int main(void)

FILE: third-party/xxhash/tests/sanity_test.c
  function abortSanityTest (line 48) | static void abortSanityTest(void) {
  function fillTestBuffer (line 62) | static void fillTestBuffer(XSUM_U8* buffer, size_t bufferLenInBytes)
  function XSUM_U8 (line 82) | static XSUM_U8* createSanityBuffer(size_t bufferLenInBytes)
  function releaseSanityBuffer (line 95) | static void releaseSanityBuffer(XSUM_U8* buffer)
  function checkResult32 (line 104) | static void checkResult32(XXH32_hash_t r1, XXH32_hash_t r2, const char* ...
  function checkResult64 (line 121) | static void checkResult64(XXH64_hash_t r1, XXH64_hash_t r2, const char* ...
  function checkResult128 (line 139) | static void checkResult128(XXH128_hash_t r1, XXH128_hash_t r2, const cha...
  function checkResultTestDataSample (line 158) | static void checkResultTestDataSample(const XSUM_U8* r1, const XSUM_U8* ...
  function testXXH32 (line 177) | static void testXXH32(
  function testXXH64 (line 218) | static void testXXH64(
  function XSUM_U32 (line 262) | static XSUM_U32 SANITY_TEST_rand(XSUM_U64* pRandSeed)
  function XSUM_U64 (line 273) | static XSUM_U64 SANITY_TEST_computeRandSeed(size_t step)
  type XXH_errorcode (line 289) | typedef XXH_errorcode (*SANITY_TEST_XXH3_update_t)(XXH3_state_t* state, ...
  function SANITY_TEST_XXH3_randomUpdate (line 298) | static void SANITY_TEST_XXH3_randomUpdate(
  function testXXH3 (line 319) | static void testXXH3(
  function testXXH3_withSecret (line 413) | static void testXXH3_withSecret(
  function testXXH128 (line 478) | static void testXXH128(
  function testXXH128_withSecret (line 579) | static void testXXH128_withSecret(
  function testSecretGenerator (line 644) | static void testSecretGenerator(
  function main (line 667) | int main(int argc, const char* argv[])

FILE: third-party/xxhash/tests/sanity_test_vectors.h
  type XSUM_testdata32_t (line 1) | typedef struct {
  type XSUM_testdata64_t (line 7) | typedef struct {
  type XSUM_testdata128_t (line 13) | typedef struct {
  type XSUM_testdata_sample_t (line 23) | typedef struct {

FILE: third-party/xxhash/tests/sanity_test_vectors_generator.c
  type XSUM_testdata32_t (line 31) | typedef struct {
  type XSUM_testdata64_t (line 37) | typedef struct {
  type XSUM_testdata128_t (line 43) | typedef struct {
  type XSUM_testdata_sample_t (line 50) | typedef struct {
  function XSUM_testdata32_t (line 63) | static XSUM_testdata32_t tvgen_XXH32(const XSUM_U8* buf, size_t len, XSU...
  function XSUM_testdata64_t (line 71) | static XSUM_testdata64_t tvgen_XXH64(const XSUM_U8* buf, size_t len, XSU...
  function XSUM_testdata64_t (line 79) | static XSUM_testdata64_t tvgen_XXH3_64bits_withSeed(const XSUM_U8* buf, ...
  function XSUM_testdata64_t (line 87) | static XSUM_testdata64_t tvgen_XXH3_64bits_withSecret(const XSUM_U8* buf...
  function XSUM_testdata128_t (line 95) | static XSUM_testdata128_t tvgen_XXH3_128bits_withSeed(const XSUM_U8* buf...
  function XSUM_testdata128_t (line 103) | static XSUM_testdata128_t tvgen_XXH3_128bits_withSecret(const XSUM_U8* b...
  function XSUM_testdata_sample_t (line 111) | static XSUM_testdata_sample_t tvgen_XXH3_generateSecret(
  function fprintf_XSUM_testdata32_t (line 136) | static void fprintf_XSUM_testdata32_t(FILE* fp, XSUM_testdata32_t const ...
  function fprintf_XSUM_testdata64_t (line 140) | static void fprintf_XSUM_testdata64_t(FILE* fp, XSUM_testdata64_t const ...
  function fprintf_XSUM_testdata128_t (line 144) | static void fprintf_XSUM_testdata128_t(FILE* fp, XSUM_testdata128_t cons...
  function fprintf_XSUM_testdata_sample_t (line 149) | static void fprintf_XSUM_testdata_sample_t(FILE* fp, XSUM_testdata_sampl...
  function fillTestBuffer (line 161) | static void fillTestBuffer(XSUM_U8* buffer, size_t bufferLenInBytes)
  function XSUM_U8 (line 181) | static XSUM_U8* createSanityBuffer(size_t bufferLenInBytes)
  function releaseSanityBuffer (line 194) | static void releaseSanityBuffer(XSUM_U8* buffer)
  function generate_sanity_test_vectors_xxh32 (line 202) | static void generate_sanity_test_vectors_xxh32(FILE* fp, size_t maxLen) {
  function generate_sanity_test_vectors_xxh64 (line 228) | static void generate_sanity_test_vectors_xxh64(FILE* fp, size_t maxLen) {
  function generate_sanity_test_vectors_xxh3 (line 254) | static void generate_sanity_test_vectors_xxh3(FILE* fp, size_t maxLen) {
  function generate_sanity_test_vectors_xxh3_withSecret (line 280) | static void generate_sanity_test_vectors_xxh3_withSecret(FILE* fp, size_...
  function generate_sanity_test_vectors_xxh128 (line 306) | static void generate_sanity_test_vectors_xxh128(FILE* fp, size_t maxLen) {
  function generate_sanity_test_vectors_xxh128_withSecret (line 331) | static void generate_sanity_test_vectors_xxh128_withSecret(FILE* fp, siz...
  function generate_sanity_test_vectors_xxh3_generateSecret (line 357) | static void generate_sanity_test_vectors_xxh3_generateSecret(FILE* fp, s...
  function generate_sanity_test_vectors (line 406) | void generate_sanity_test_vectors(size_t maxLen) {
  function main (line 457) | int main(int argc, const char* argv[])

FILE: third-party/xxhash/xxh_x86dispatch.c
  function XXH_cpuid (line 254) | static void XXH_cpuid(xxh_u32 eax, xxh_u32 ecx, xxh_u32* abcd)
  function xxh_u64 (line 306) | static xxh_u64 XXH_xgetbv(void)
  function XXH_featureTest (line 343) | int XXH_featureTest(void)
  type XXH64_hash_t (line 583) | typedef XXH64_hash_t (*XXH3_dispatchx86_hashLong64_withSeed)(XXH_NOESCAP...
  type XXH64_hash_t (line 585) | typedef XXH64_hash_t (*XXH3_dispatchx86_hashLong64_withSecret)(XXH_NOESC...
  type XXH_errorcode (line 587) | typedef XXH_errorcode (*XXH3_dispatchx86_update)(XXH_NOESCAPE XXH3_state...
  type XXH_dispatchFunctions_s (line 589) | typedef struct {
  type XXH128_hash_t (line 631) | typedef XXH128_hash_t (*XXH3_dispatchx86_hashLong128_default)(XXH_NOESCA...
  type XXH128_hash_t (line 633) | typedef XXH128_hash_t (*XXH3_dispatchx86_hashLong128_withSeed)(XXH_NOESC...
  type XXH128_hash_t (line 635) | typedef XXH128_hash_t (*XXH3_dispatchx86_hashLong128_withSecret)(XXH_NOE...
  type XXH_dispatch128Functions_s (line 637) | typedef struct {
  function XXH_CONSTRUCTOR (line 681) | static XXH_CONSTRUCTOR void XXH_setDispatch(void)
  function XXH64_hash_t (line 703) | static XXH64_hash_t
  function XXH64_hash_t (line 713) | XXH64_hash_t XXH3_64bits_dispatch(XXH_NOESCAPE const void* input, size_t...
  function XXH64_hash_t (line 718) | static XXH64_hash_t
  function XXH64_hash_t (line 728) | XXH64_hash_t XXH3_64bits_withSeed_dispatch(XXH_NOESCAPE const void* inpu...
  function XXH64_hash_t (line 733) | static XXH64_hash_t
  function XXH64_hash_t (line 743) | XXH64_hash_t XXH3_64bits_withSecret_dispatch(XXH_NOESCAPE const void* in...
  function XXH_errorcode (line 748) | XXH_errorcode
  function XXH128_hash_t (line 763) | static XXH128_hash_t
  function XXH128_hash_t (line 773) | XXH128_hash_t XXH3_128bits_dispatch(XXH_NOESCAPE const void* input, size...
  function XXH128_hash_t (line 778) | static XXH128_hash_t
  function XXH128_hash_t (line 788) | XXH128_hash_t XXH3_128bits_withSeed_dispatch(XXH_NOESCAPE const void* in...
  function XXH128_hash_t (line 793) | static XXH128_hash_t
  function XXH128_hash_t (line 803) | XXH128_hash_t XXH3_128bits_withSecret_dispatch(XXH_NOESCAPE const void* ...
  function XXH_errorcode (line 808) | XXH_errorcode

FILE: third-party/xxhash/xxhash.h
  type XXH_errorcode (line 572) | typedef enum {
  type XXH32_hash_t (line 587) | typedef uint32_t XXH32_hash_t;
  type XXH32_hash_t (line 597) | typedef uint32_t XXH32_hash_t;
  type XXH32_hash_t (line 602) | typedef unsigned int XXH32_hash_t;
  type XXH32_hash_t (line 604) | typedef unsigned long XXH32_hash_t;
  type XXH32_state_t (line 653) | typedef struct XXH32_state_s XXH32_state_t;
  type XXH32_canonical_t (line 754) | typedef struct {
  type XXH64_hash_t (line 866) | typedef uint64_t XXH64_hash_t;
  type XXH64_hash_t (line 875) | typedef uint64_t XXH64_hash_t;
  type XXH64_hash_t (line 880) | typedef unsigned long XXH64_hash_t;
  type XXH64_hash_t (line 883) | typedef unsigned long long XXH64_hash_t;
  type XXH64_state_t (line 927) | typedef struct XXH64_state_s XXH64_state_t;
  type XXH64_canonical_t (line 1028) | typedef struct { unsigned char digest[sizeof(XXH64_hash_t)]; } XXH64_can...
  type XXH3_state_t (line 1243) | typedef struct XXH3_state_s XXH3_state_t;
  type XXH128_hash_t (line 1382) | typedef struct {
  type XXH128_canonical_t (line 1605) | typedef struct { unsigned char digest[sizeof(XXH128_hash_t)]; } XXH128_c...
  type XXH32_state_s (line 1672) | struct XXH32_state_s {
  type XXH64_state_s (line 1696) | struct XXH64_state_s {
  type XXH3_state_s (line 1770) | struct XXH3_state_s {
  function XXH_CONSTF (line 2369) | static XXH_CONSTF void* XXH_malloc(size_t s) { (void)s; return NULL; }
  function XXH_free (line 2370) | static void XXH_free(void* p) { (void)p; }
  function XXH_MALLOCF (line 2384) | static XXH_MALLOCF void* XXH_malloc(size_t s) { return malloc(s); }
  function XXH_free (line 2390) | static void XXH_free(void* p) { free(p); }
  type xxh_u8 (line 2550) | typedef uint8_t xxh_u8;
  type xxh_u8 (line 2552) | typedef unsigned char xxh_u8;
  type XXH32_hash_t (line 2554) | typedef XXH32_hash_t xxh_u32;
  function xxh_u32 (line 2626) | static xxh_u32 XXH_read32(const void* memPtr) { return *(const xxh_u32*)...
  type unalign (line 2638) | typedef union { xxh_u32 u32; } __attribute__((__packed__)) unalign;
  function xxh_u32 (line 2640) | static xxh_u32 XXH_read32(const void* ptr)
  function xxh_u32 (line 2652) | static xxh_u32 XXH_read32(const void* memPtr)
  function XXH_isLittleEndian (line 2699) | static int XXH_isLittleEndian(void)
  function xxh_u32 (line 2813) | static xxh_u32 XXH_swap32 (xxh_u32 x)
  type XXH_alignment (line 2831) | typedef enum {
  function XXH_FORCE_INLINE (line 2843) | XXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* memPtr)
  function XXH_FORCE_INLINE (line 2852) | XXH_FORCE_INLINE xxh_u32 XXH_readBE32(const void* memPtr)
  function XXH_FORCE_INLINE (line 2862) | XXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* ptr)
  function xxh_u32 (line 2867) | static xxh_u32 XXH_readBE32(const void* ptr)
  function XXH_FORCE_INLINE (line 2873) | XXH_FORCE_INLINE xxh_u32
  function XXH_versionNumber (line 2888) | XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NU...
  function xxh_u32 (line 2928) | static xxh_u32 XXH32_round(xxh_u32 acc, xxh_u32 input)
  function xxh_u32 (line 2985) | static xxh_u32 XXH32_avalanche(xxh_u32 hash)
  function XXH_FORCE_INLINE (line 3001) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 3017) | XXH_FORCE_INLINE const xxh_u8 *
  function xxh_u32 (line 3044) | xxh_u32
  function XXH_PUREF (line 3067) | static XXH_PUREF xxh_u32
  function xxh_u32 (line 3156) | xxh_u32
  function XXH_PUBLIC_API (line 3180) | XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t len, XXH32_...
  function XXH_PUBLIC_API (line 3203) | XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
  function XXH_PUBLIC_API (line 3208) | XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
  function XXH_PUBLIC_API (line 3215) | XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32...
  function XXH_PUBLIC_API (line 3221) | XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, XXH32_...
  function XXH_PUBLIC_API (line 3231) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 3278) | XXH_PUBLIC_API XXH32_hash_t XXH32_digest(const XXH32_state_t* state)
  function XXH_PUBLIC_API (line 3297) | XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH3...
  function XXH_PUBLIC_API (line 3304) | XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonica...
  type XXH64_hash_t (line 3322) | typedef XXH64_hash_t xxh_u64;
  function xxh_u64 (line 3336) | static xxh_u64 XXH_read64(const void* memPtr)
  type unalign64 (line 3351) | typedef union { xxh_u32 u32; xxh_u64 u64; } __attribute__((__packed__)) ...
  function xxh_u64 (line 3353) | static xxh_u64 XXH_read64(const void* ptr)
  function xxh_u64 (line 3365) | static xxh_u64 XXH_read64(const void* memPtr)
  function xxh_u64 (line 3379) | static xxh_u64 XXH_swap64(xxh_u64 x)
  function XXH_FORCE_INLINE (line 3396) | XXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* memPtr)
  function XXH_FORCE_INLINE (line 3409) | XXH_FORCE_INLINE xxh_u64 XXH_readBE64(const void* memPtr)
  function XXH_FORCE_INLINE (line 3423) | XXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* ptr)
  function xxh_u64 (line 3428) | static xxh_u64 XXH_readBE64(const void* ptr)
  function XXH_FORCE_INLINE (line 3434) | XXH_FORCE_INLINE xxh_u64
  function xxh_u64 (line 3469) | static xxh_u64 XXH64_round(xxh_u64 acc, xxh_u64 input)
  function xxh_u64 (line 3494) | static xxh_u64 XXH64_mergeRound(xxh_u64 acc, xxh_u64 val)
  function xxh_u64 (line 3503) | static xxh_u64 XXH64_avalanche(xxh_u64 hash)
  function XXH_FORCE_INLINE (line 3520) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 3536) | XXH_FORCE_INLINE const xxh_u8 *
  function xxh_u64 (line 3572) | xxh_u64
  function xxh_u64 (line 3610) | xxh_u64
  function xxh_u64 (line 3654) | xxh_u64
  function XXH_PUBLIC_API (line 3678) | XXH_PUBLIC_API XXH64_hash_t XXH64 (XXH_NOESCAPE const void* input, size_...
  function XXH_PUBLIC_API (line 3700) | XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
  function XXH_PUBLIC_API (line 3705) | XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
  function XXH_PUBLIC_API (line 3712) | XXH_PUBLIC_API void XXH64_copyState(XXH_NOESCAPE XXH64_state_t* dstState...
  function XXH_PUBLIC_API (line 3718) | XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH_NOESCAPE XXH64_state_t* sta...
  function XXH_PUBLIC_API (line 3727) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 3773) | XXH_PUBLIC_API XXH64_hash_t XXH64_digest(XXH_NOESCAPE const XXH64_state_...
  function XXH_PUBLIC_API (line 3792) | XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH_NOESCAPE XXH64_canonical...
  function XXH_PUBLIC_API (line 3800) | XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(XXH_NOESCAPE const X...
  type uint64x2_t (line 4090) | typedef uint64x2_t xxh_aliasing_uint64x2_t
  function XXH_FORCE_INLINE (line 4106) | XXH_FORCE_INLINE uint64x2_t XXH_vld1q_u64(void const* ptr) /* silence -W...
  function XXH_FORCE_INLINE (line 4111) | XXH_FORCE_INLINE uint64x2_t XXH_vld1q_u64(void const* ptr)
  function XXH_FORCE_INLINE (line 4126) | XXH_FORCE_INLINE uint64x2_t
  function XXH_FORCE_INLINE (line 4133) | XXH_FORCE_INLINE uint64x2_t
  function XXH_FORCE_INLINE (line 4141) | XXH_FORCE_INLINE uint64x2_t
  function XXH_FORCE_INLINE (line 4148) | XXH_FORCE_INLINE uint64x2_t
  type xxh_u64x2 (line 4239) | typedef __vector unsigned long long xxh_u64x2;
  type xxh_u8x16 (line 4240) | typedef __vector unsigned char xxh_u8x16;
  type xxh_u32x4 (line 4241) | typedef __vector unsigned xxh_u32x4;
  type xxh_u64x2 (line 4246) | typedef xxh_u64x2 xxh_aliasing_u64x2
  function XXH_FORCE_INLINE (line 4267) | XXH_FORCE_INLINE xxh_u64x2 XXH_vec_revb(xxh_u64x2 val)
  function XXH_FORCE_INLINE (line 4279) | XXH_FORCE_INLINE xxh_u64x2 XXH_vec_loadu(const void *ptr)
  function XXH_FORCE_INLINE (line 4307) | XXH_FORCE_INLINE xxh_u64x2 XXH_vec_mulo(xxh_u32x4 a, xxh_u32x4 b)
  function XXH_FORCE_INLINE (line 4313) | XXH_FORCE_INLINE xxh_u64x2 XXH_vec_mule(xxh_u32x4 a, xxh_u32x4 b)
  function XXH_FORCE_INLINE (line 4404) | XXH_FORCE_INLINE xxh_u64
  function XXH128_hash_t (line 4431) | static XXH128_hash_t
  function xxh_u64 (line 4565) | static xxh_u64
  function xxh_u64 (line 4573) | xxh_u64 XXH_xorshift64(xxh_u64 v64, int shift)
  function XXH64_hash_t (line 4583) | static XXH64_hash_t XXH3_avalanche(xxh_u64 h64)
  function XXH64_hash_t (line 4596) | static XXH64_hash_t XXH3_rrmxmx(xxh_u64 h64, xxh_u64 len)
  function XXH64_hash_t (line 4640) | XXH64_hash_t
  function XXH64_hash_t (line 4662) | XXH64_hash_t
  function XXH64_hash_t (line 4678) | XXH64_hash_t
  function XXH64_hash_t (line 4695) | XXH64_hash_t
  function XXH_FORCE_INLINE (line 4732) | XXH_FORCE_INLINE xxh_u64 XXH3_mix16B(const xxh_u8* XXH_RESTRICT input,
  function XXH64_hash_t (line 4765) | XXH64_hash_t
  function XXH64_hash_t (line 4801) | XXH64_hash_t
  function XXH_FORCE_INLINE (line 4913) | XXH_FORCE_INLINE void XXH_writeLE64(void* dst, xxh_u64 v64)
  type xxh_i64 (line 4927) | typedef int64_t xxh_i64;
  type xxh_i64 (line 4930) | typedef long long xxh_i64;
  function XXH3_accumulate_512_avx512 (line 4964) | void
  function XXH_FORCE_INLINE (line 4991) | XXH_FORCE_INLINE XXH_TARGET_AVX512 XXH3_ACCUMULATE_TEMPLATE(avx512)
  function XXH3_initCustomSecret_avx512 (line 5037) | void
  function XXH3_accumulate_512_avx2 (line 5067) | void
  function XXH_FORCE_INLINE (line 5100) | XXH_FORCE_INLINE XXH_TARGET_AVX2 XXH3_ACCUMULATE_TEMPLATE(avx2)
  function XXH3_initCustomSecret_avx2 (line 5131) | void XXH3_initCustomSecret_avx2(void* XXH_RESTRICT customSecret, xxh_u64...
  function XXH3_accumulate_512_sse2 (line 5173) | void
  function XXH_FORCE_INLINE (line 5207) | XXH_FORCE_INLINE XXH_TARGET_SSE2 XXH3_ACCUMULATE_TEMPLATE(sse2)
  function XXH3_initCustomSecret_sse2 (line 5238) | void XXH3_initCustomSecret_sse2(void* XXH_RESTRICT customSecret, xxh_u64...
  function XXH_FORCE_INLINE (line 5308) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 5434) | XXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(neon)
  function XXH_FORCE_INLINE (line 5495) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 5529) | XXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(vsx)
  function XXH_FORCE_INLINE (line 5565) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 5605) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 5675) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 5706) | XXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(lsx)
  function XXH_FORCE_INLINE (line 5754) | XXH_FORCE_INLINE xxh_u64
  function XXH_FORCE_INLINE (line 5763) | XXH_FORCE_INLINE xxh_u64
  function XXH_FORCE_INLINE (line 5777) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 5800) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 5817) | XXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(scalar)
  function XXH_FORCE_INLINE (line 5849) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 5858) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 5987) | XXH_FORCE_INLINE void
  function XXH_FORCE_INLINE (line 6020) | XXH_FORCE_INLINE xxh_u64
  function XXH_PUREF (line 6028) | static XXH_PUREF XXH64_hash_t
  function XXH_PUREF (line 6058) | static XXH_PUREF XXH64_hash_t
  function XXH_FORCE_INLINE (line 6067) | XXH_FORCE_INLINE XXH64_hash_t
  function XXH3_WITH_SECRET_INLINE (line 6090) | XXH3_WITH_SECRET_INLINE XXH64_hash_t
  function XXH64_hash_t (line 6104) | XXH64_hash_t
  function XXH_FORCE_INLINE (line 6123) | XXH_FORCE_INLINE XXH64_hash_t
  function XXH_NO_INLINE (line 6146) | XXH_NO_INLINE XXH64_hash_t
  type XXH64_hash_t (line 6156) | typedef XXH64_hash_t (*XXH3_hashLong64_f)(const void* XXH_RESTRICT, size_t,
  function XXH_FORCE_INLINE (line 6159) | XXH_FORCE_INLINE XXH64_hash_t
  function XXH_PUBLIC_API (line 6185) | XXH_PUBLIC_API XXH64_hash_t XXH3_64bits(XXH_NOESCAPE const void* input, ...
  function XXH_PUBLIC_API (line 6191) | XXH_PUBLIC_API XXH64_hash_t
  function XXH_PUBLIC_API (line 6198) | XXH_PUBLIC_API XXH64_hash_t
  function XXH_PUBLIC_API (line 6204) | XXH_PUBLIC_API XXH64_hash_t
  function XXH_MALLOCF (line 6238) | static XXH_MALLOCF void* XXH_alignedMalloc(size_t s, size_t align)
  function XXH_alignedFree (line 6269) | static void XXH_alignedFree(void* p)
  function XXH_PUBLIC_API (line 6291) | XXH_PUBLIC_API XXH3_state_t* XXH3_createState(void)
  function XXH_PUBLIC_API (line 6311) | XXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr)
  function XXH_PUBLIC_API (line 6318) | XXH_PUBLIC_API void
  function XXH3_reset_internal (line 6324) | static void
  function XXH_PUBLIC_API (line 6352) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 6361) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 6372) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 6384) | XXH_PUBLIC_API XXH_errorcode
  function XXH_FORCE_INLINE (line 6412) | XXH_FORCE_INLINE const xxh_u8 *
  function XXH_PUBLIC_API (line 6536) | XXH_PUBLIC_API XXH_errorcode
  function XXH_FORCE_INLINE (line 6544) | XXH_FORCE_INLINE void
  function XXH_PUBLIC_API (line 6582) | XXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (XXH_NOESCAPE const XXH3_...
  function XXH128_hash_t (line 6616) | XXH128_hash_t
  function XXH128_hash_t (line 6645) | XXH128_hash_t
  function XXH128_hash_t (line 6672) | XXH128_hash_t
  function XXH128_hash_t (line 6747) | XXH128_hash_t
  function XXH_FORCE_INLINE (line 6766) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH128_hash_t (line 6778) | XXH128_hash_t
  function XXH128_hash_t (line 6822) | XXH128_hash_t
  function XXH_PUREF (line 6880) | static XXH_PUREF XXH128_hash_t
  function XXH_FORCE_INLINE (line 6891) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH128_hash_t (line 6910) | XXH128_hash_t
  function XXH3_WITH_SECRET_INLINE (line 6927) | XXH3_WITH_SECRET_INLINE XXH128_hash_t
  function XXH_FORCE_INLINE (line 6937) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH_NO_INLINE (line 6958) | XXH_NO_INLINE XXH128_hash_t
  type XXH128_hash_t (line 6967) | typedef XXH128_hash_t (*XXH3_hashLong128_f)(const void* XXH_RESTRICT, si...
  function XXH_FORCE_INLINE (line 6970) | XXH_FORCE_INLINE XXH128_hash_t
  function XXH_PUBLIC_API (line 6995) | XXH_PUBLIC_API XXH128_hash_t XXH3_128bits(XXH_NOESCAPE const void* input...
  function XXH_PUBLIC_API (line 7003) | XXH_PUBLIC_API XXH128_hash_t
  function XXH_PUBLIC_API (line 7012) | XXH_PUBLIC_API XXH128_hash_t
  function XXH_PUBLIC_API (line 7021) | XXH_PUBLIC_API XXH128_hash_t
  function XXH_PUBLIC_API (line 7030) | XXH_PUBLIC_API XXH128_hash_t
  function XXH_PUBLIC_API (line 7045) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 7052) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 7059) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 7066) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 7073) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 7080) | XXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (XXH_NOESCAPE const XXH...
  function XXH_PUBLIC_API (line 7102) | XXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2)
  function XXH_PUBLIC_API (line 7113) | XXH_PUBLIC_API int XXH128_cmp(XXH_NOESCAPE const void* h128_1, XXH_NOESC...
  function XXH_PUBLIC_API (line 7126) | XXH_PUBLIC_API void
  function XXH_PUBLIC_API (line 7139) | XXH_PUBLIC_API XXH128_hash_t
  function XXH_FORCE_INLINE (line 7156) | XXH_FORCE_INLINE void XXH3_combine16(void* dst, XXH128_hash_t h128)
  function XXH_PUBLIC_API (line 7163) | XXH_PUBLIC_API XXH_errorcode
  function XXH_PUBLIC_API (line 7208) | XXH_PUBLIC_API void

FILE: third-party/zlib/adler32.c
  function uLong (line 61) | uLong ZEXPORT adler32_z(uLong adler, const Bytef *buf, z_size_t len) {
  function uLong (line 128) | uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len) {
  function local (line 133) | local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2) {
  function uLong (line 158) | uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2, z_off_t len2) {
  function uLong (line 162) | uLong ZEXPORT adler32_combine64(uLong adler1, uLong adler2, z_off64_t le...

FILE: third-party/zlib/compress.c
  function compress2 (line 22) | int ZEXPORT compress2(Bytef *dest, uLongf *destLen, const Bytef *source,
  function compress (line 63) | int ZEXPORT compress(Bytef *dest, uLongf *destLen, const Bytef *source,
  function uLong (line 72) | uLong ZEXPORT compressBound(uLong sourceLen) {