Copy disabled (too large)
Download .txt
Showing preview only (10,547K chars total). Download the full file to get everything.
Repository: anelson/tracers
Branch: master
Commit: ae677b0f3b41
Files: 1466
Total size: 9.7 MB
Directory structure:
gitextract_mpfftwx2/
├── .cirrus.yml
├── .gitignore
├── .gitmodules
├── .tmuxp.yaml
├── Cargo.toml
├── LICENSE
├── LICENSE-APACHE
├── LICENSE-MIT
├── README.md
├── azure-pipelines.yml
├── bin/
│ ├── pre-publish.sh
│ └── publish.sh
├── examples/
│ └── simple/
│ ├── Cargo.toml
│ ├── build.rs
│ └── src/
│ └── main.rs
├── scripts/
│ ├── build.bat
│ ├── build.sh
│ ├── test.bat
│ └── test.sh
├── tracers/
│ ├── Cargo.toml
│ ├── benches/
│ │ └── probe_firing.rs
│ ├── build.rs
│ ├── examples/
│ │ ├── simple.rs
│ │ └── submodules.rs
│ ├── src/
│ │ ├── bin/
│ │ │ ├── profile_target.rs
│ │ │ ├── stap_probes.d
│ │ │ ├── stap_probes.h
│ │ │ ├── stap_probes.o
│ │ │ ├── stap_probes.o.dtrace-temp.c
│ │ │ └── testfire.rs
│ │ └── lib.rs
│ └── tests/
│ ├── custom_provider_names.rs
│ └── simple.rs
├── tracers-build/
│ ├── Cargo.toml
│ └── src/
│ └── lib.rs
├── tracers-codegen/
│ ├── Cargo.toml
│ ├── src/
│ │ ├── argtypes.rs
│ │ ├── build_rs.rs
│ │ ├── cache.rs
│ │ ├── cargo.rs
│ │ ├── deps.rs
│ │ ├── error.rs
│ │ ├── gen/
│ │ │ ├── common/
│ │ │ │ └── mod.rs
│ │ │ ├── dynamic/
│ │ │ │ ├── mod.rs
│ │ │ │ ├── probe_call.rs
│ │ │ │ └── provider_trait.rs
│ │ │ ├── mod.rs
│ │ │ └── static/
│ │ │ ├── c.rs
│ │ │ ├── mod.rs
│ │ │ ├── native_code/
│ │ │ │ ├── .gitignore
│ │ │ │ ├── mod.rs
│ │ │ │ └── target/
│ │ │ │ ├── lttng.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── stap.rs
│ │ │ ├── probe_call.rs
│ │ │ └── provider_trait.rs
│ │ ├── hashing.rs
│ │ ├── lib.rs
│ │ ├── proc_macros.rs
│ │ ├── serde_helpers.rs
│ │ ├── spec/
│ │ │ ├── init_provider.rs
│ │ │ ├── mod.rs
│ │ │ ├── probe.rs
│ │ │ ├── probe_arg.rs
│ │ │ ├── probe_call.rs
│ │ │ └── provider.rs
│ │ ├── syn_helpers.rs
│ │ └── testdata.rs
│ ├── templates/
│ │ ├── lttng/
│ │ │ ├── provider.tp
│ │ │ └── provider_wrapper.cpp
│ │ └── stap/
│ │ ├── provider_wrapper.cpp
│ │ └── sys_sdt.h
│ └── testdata/
│ ├── complexlib/
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── examples/
│ │ │ └── ex1.rs
│ │ ├── src/
│ │ │ ├── bin/
│ │ │ │ ├── bin1.rs
│ │ │ │ └── bin2.rs
│ │ │ └── lib.rs
│ │ └── tests/
│ │ ├── static/
│ │ │ └── mod.rs
│ │ ├── test1.rs
│ │ └── test2.rs
│ ├── errors/
│ │ ├── Cargo.toml
│ │ ├── src/
│ │ │ ├── child_mod/
│ │ │ │ ├── grandchild_mod.rs
│ │ │ │ └── mod.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ ├── compile_errors.rs
│ │ └── with_errors/
│ │ └── mod.rs
│ ├── simplebin/
│ │ ├── Cargo.toml
│ │ └── src/
│ │ ├── child_module.rs
│ │ └── main.rs
│ └── simplelib/
│ ├── Cargo.toml
│ ├── build.rs
│ └── src/
│ ├── child_module.rs
│ └── lib.rs
├── tracers-core/
│ ├── Cargo.toml
│ ├── build.rs
│ └── src/
│ ├── argtypes/
│ │ ├── bool.rs
│ │ ├── cstring.rs
│ │ ├── int.rs
│ │ ├── native.rs
│ │ ├── option.rs
│ │ ├── pointer.rs
│ │ ├── refs.rs
│ │ └── string.rs
│ ├── argtypes.rs
│ ├── dynamic.rs
│ └── lib.rs
├── tracers-dyn-noop/
│ ├── Cargo.toml
│ ├── build.rs
│ └── src/
│ ├── lib.rs
│ ├── probe.rs
│ ├── provider.rs
│ └── tracer.rs
├── tracers-dyn-stap/
│ ├── Cargo.toml
│ ├── build.rs
│ └── src/
│ ├── lib.rs
│ ├── probe.rs
│ ├── provider.rs
│ └── tracer.rs
├── tracers-libelf-sys/
│ ├── COPYING-LGPLV3
│ ├── Cargo.toml
│ ├── LICENSE
│ ├── bindgen.sh
│ ├── build.rs
│ ├── src/
│ │ ├── lib.h
│ │ ├── lib.rs
│ │ └── libelf.rs
│ ├── update-elfutils.sh
│ └── vendor/
│ └── libelf/
│ ├── ABOUT-NLS
│ ├── AUTHORS
│ ├── CONTRIBUTING
│ ├── COPYING
│ ├── COPYING-GPLV2
│ ├── COPYING-LGPLV3
│ ├── ChangeLog
│ ├── GPG-KEY
│ ├── INSTALL
│ ├── Makefile.am
│ ├── Makefile.in
│ ├── NEWS
│ ├── NOTES
│ ├── README
│ ├── THANKS
│ ├── TODO
│ ├── aclocal.m4
│ ├── backends/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── aarch64_cfi.c
│ │ ├── aarch64_corenote.c
│ │ ├── aarch64_init.c
│ │ ├── aarch64_initreg.c
│ │ ├── aarch64_regs.c
│ │ ├── aarch64_reloc.def
│ │ ├── aarch64_retval.c
│ │ ├── aarch64_symbol.c
│ │ ├── aarch64_unwind.c
│ │ ├── alpha_auxv.c
│ │ ├── alpha_corenote.c
│ │ ├── alpha_init.c
│ │ ├── alpha_regs.c
│ │ ├── alpha_reloc.def
│ │ ├── alpha_retval.c
│ │ ├── alpha_symbol.c
│ │ ├── arm_attrs.c
│ │ ├── arm_auxv.c
│ │ ├── arm_cfi.c
│ │ ├── arm_corenote.c
│ │ ├── arm_init.c
│ │ ├── arm_initreg.c
│ │ ├── arm_regs.c
│ │ ├── arm_reloc.def
│ │ ├── arm_retval.c
│ │ ├── arm_symbol.c
│ │ ├── bpf_init.c
│ │ ├── bpf_regs.c
│ │ ├── bpf_reloc.def
│ │ ├── bpf_symbol.c
│ │ ├── common-reloc.c
│ │ ├── i386_auxv.c
│ │ ├── i386_cfi.c
│ │ ├── i386_corenote.c
│ │ ├── i386_init.c
│ │ ├── i386_initreg.c
│ │ ├── i386_regs.c
│ │ ├── i386_reloc.def
│ │ ├── i386_retval.c
│ │ ├── i386_symbol.c
│ │ ├── i386_syscall.c
│ │ ├── i386_unwind.c
│ │ ├── ia64_init.c
│ │ ├── ia64_regs.c
│ │ ├── ia64_reloc.def
│ │ ├── ia64_retval.c
│ │ ├── ia64_symbol.c
│ │ ├── libebl_CPU.h
│ │ ├── linux-core-note.c
│ │ ├── m68k_cfi.c
│ │ ├── m68k_corenote.c
│ │ ├── m68k_init.c
│ │ ├── m68k_initreg.c
│ │ ├── m68k_regs.c
│ │ ├── m68k_reloc.def
│ │ ├── m68k_retval.c
│ │ ├── m68k_symbol.c
│ │ ├── ppc64_corenote.c
│ │ ├── ppc64_init.c
│ │ ├── ppc64_reloc.def
│ │ ├── ppc64_resolve_sym.c
│ │ ├── ppc64_retval.c
│ │ ├── ppc64_symbol.c
│ │ ├── ppc64_unwind.c
│ │ ├── ppc_attrs.c
│ │ ├── ppc_auxv.c
│ │ ├── ppc_cfi.c
│ │ ├── ppc_corenote.c
│ │ ├── ppc_init.c
│ │ ├── ppc_initreg.c
│ │ ├── ppc_regs.c
│ │ ├── ppc_reloc.def
│ │ ├── ppc_retval.c
│ │ ├── ppc_symbol.c
│ │ ├── ppc_syscall.c
│ │ ├── riscv64_corenote.c
│ │ ├── riscv_cfi.c
│ │ ├── riscv_corenote.c
│ │ ├── riscv_init.c
│ │ ├── riscv_initreg.c
│ │ ├── riscv_regs.c
│ │ ├── riscv_reloc.def
│ │ ├── riscv_retval.c
│ │ ├── riscv_symbol.c
│ │ ├── s390_cfi.c
│ │ ├── s390_corenote.c
│ │ ├── s390_init.c
│ │ ├── s390_initreg.c
│ │ ├── s390_regs.c
│ │ ├── s390_reloc.def
│ │ ├── s390_retval.c
│ │ ├── s390_symbol.c
│ │ ├── s390_unwind.c
│ │ ├── s390x_corenote.c
│ │ ├── sh_corenote.c
│ │ ├── sh_init.c
│ │ ├── sh_regs.c
│ │ ├── sh_reloc.def
│ │ ├── sh_retval.c
│ │ ├── sh_symbol.c
│ │ ├── sparc64_corenote.c
│ │ ├── sparc_attrs.c
│ │ ├── sparc_auxv.c
│ │ ├── sparc_cfi.c
│ │ ├── sparc_corenote.c
│ │ ├── sparc_init.c
│ │ ├── sparc_initreg.c
│ │ ├── sparc_regs.c
│ │ ├── sparc_reloc.def
│ │ ├── sparc_retval.c
│ │ ├── sparc_symbol.c
│ │ ├── tilegx_corenote.c
│ │ ├── tilegx_init.c
│ │ ├── tilegx_regs.c
│ │ ├── tilegx_reloc.def
│ │ ├── tilegx_retval.c
│ │ ├── tilegx_symbol.c
│ │ ├── x32_corenote.c
│ │ ├── x86_64_cfi.c
│ │ ├── x86_64_corenote.c
│ │ ├── x86_64_init.c
│ │ ├── x86_64_initreg.c
│ │ ├── x86_64_regs.c
│ │ ├── x86_64_reloc.def
│ │ ├── x86_64_retval.c
│ │ ├── x86_64_symbol.c
│ │ ├── x86_64_syscall.c
│ │ ├── x86_64_unwind.c
│ │ └── x86_corenote.c
│ ├── config/
│ │ ├── 10-default-yama-scope.conf
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── ar-lib
│ │ ├── compile
│ │ ├── config.guess
│ │ ├── config.sub
│ │ ├── depcomp
│ │ ├── elfutils.spec.in
│ │ ├── eu.am
│ │ ├── install-sh
│ │ ├── known-dwarf.awk
│ │ ├── libdw.pc.in
│ │ ├── libelf.pc.in
│ │ ├── missing
│ │ ├── test-driver
│ │ ├── version.h.in
│ │ └── ylwrap
│ ├── config.h.in
│ ├── configure
│ ├── configure.ac
│ ├── elfutils.spec
│ ├── lib/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── bpf.h
│ │ ├── color.c
│ │ ├── color.h
│ │ ├── crc32.c
│ │ ├── crc32_file.c
│ │ ├── dynamicsizehash.c
│ │ ├── dynamicsizehash.h
│ │ ├── eu-config.h
│ │ ├── fixedsizehash.h
│ │ ├── libeu.h
│ │ ├── list.h
│ │ ├── next_prime.c
│ │ ├── printversion.c
│ │ ├── printversion.h
│ │ ├── system.h
│ │ ├── xmalloc.c
│ │ ├── xstrdup.c
│ │ └── xstrndup.c
│ ├── libasm/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── asm_abort.c
│ │ ├── asm_addint16.c
│ │ ├── asm_addint32.c
│ │ ├── asm_addint64.c
│ │ ├── asm_addint8.c
│ │ ├── asm_addsleb128.c
│ │ ├── asm_addstrz.c
│ │ ├── asm_adduint16.c
│ │ ├── asm_adduint32.c
│ │ ├── asm_adduint64.c
│ │ ├── asm_adduint8.c
│ │ ├── asm_adduleb128.c
│ │ ├── asm_align.c
│ │ ├── asm_begin.c
│ │ ├── asm_end.c
│ │ ├── asm_error.c
│ │ ├── asm_fill.c
│ │ ├── asm_getelf.c
│ │ ├── asm_newabssym.c
│ │ ├── asm_newcomsym.c
│ │ ├── asm_newscn.c
│ │ ├── asm_newscn_ingrp.c
│ │ ├── asm_newscngrp.c
│ │ ├── asm_newsubscn.c
│ │ ├── asm_newsym.c
│ │ ├── asm_scngrp_newsignature.c
│ │ ├── disasm_begin.c
│ │ ├── disasm_cb.c
│ │ ├── disasm_end.c
│ │ ├── disasm_str.c
│ │ ├── libasm.h
│ │ ├── libasmP.h
│ │ ├── symbolhash.c
│ │ └── symbolhash.h
│ ├── libcpu/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── bpf_disasm.c
│ │ ├── defs/
│ │ │ └── i386
│ │ ├── i386_data.h
│ │ ├── i386_dis.h
│ │ ├── i386_disasm.c
│ │ ├── i386_gendis.c
│ │ ├── i386_lex.c
│ │ ├── i386_lex.l
│ │ ├── i386_parse.c
│ │ ├── i386_parse.h
│ │ ├── i386_parse.y
│ │ ├── memory-access.h
│ │ ├── x86_64_dis.h
│ │ └── x86_64_disasm.c
│ ├── libdw/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── cfi.c
│ │ ├── cfi.h
│ │ ├── cie.c
│ │ ├── dwarf.h
│ │ ├── dwarf_abbrev_hash.c
│ │ ├── dwarf_abbrev_hash.h
│ │ ├── dwarf_abbrevhaschildren.c
│ │ ├── dwarf_addrdie.c
│ │ ├── dwarf_aggregate_size.c
│ │ ├── dwarf_arrayorder.c
│ │ ├── dwarf_attr.c
│ │ ├── dwarf_attr_integrate.c
│ │ ├── dwarf_begin.c
│ │ ├── dwarf_begin_elf.c
│ │ ├── dwarf_bitoffset.c
│ │ ├── dwarf_bitsize.c
│ │ ├── dwarf_bytesize.c
│ │ ├── dwarf_cfi_addrframe.c
│ │ ├── dwarf_cfi_end.c
│ │ ├── dwarf_child.c
│ │ ├── dwarf_cu_die.c
│ │ ├── dwarf_cu_getdwarf.c
│ │ ├── dwarf_cu_info.c
│ │ ├── dwarf_cuoffset.c
│ │ ├── dwarf_decl_column.c
│ │ ├── dwarf_decl_file.c
│ │ ├── dwarf_decl_line.c
│ │ ├── dwarf_default_lower_bound.c
│ │ ├── dwarf_die_addr_die.c
│ │ ├── dwarf_diecu.c
│ │ ├── dwarf_diename.c
│ │ ├── dwarf_dieoffset.c
│ │ ├── dwarf_end.c
│ │ ├── dwarf_entry_breakpoints.c
│ │ ├── dwarf_entrypc.c
│ │ ├── dwarf_error.c
│ │ ├── dwarf_filesrc.c
│ │ ├── dwarf_formaddr.c
│ │ ├── dwarf_formblock.c
│ │ ├── dwarf_formflag.c
│ │ ├── dwarf_formref.c
│ │ ├── dwarf_formref_die.c
│ │ ├── dwarf_formsdata.c
│ │ ├── dwarf_formstring.c
│ │ ├── dwarf_formudata.c
│ │ ├── dwarf_frame_cfa.c
│ │ ├── dwarf_frame_info.c
│ │ ├── dwarf_frame_register.c
│ │ ├── dwarf_func_inline.c
│ │ ├── dwarf_get_units.c
│ │ ├── dwarf_getabbrev.c
│ │ ├── dwarf_getabbrevattr.c
│ │ ├── dwarf_getabbrevcode.c
│ │ ├── dwarf_getabbrevtag.c
│ │ ├── dwarf_getalt.c
│ │ ├── dwarf_getarange_addr.c
│ │ ├── dwarf_getarangeinfo.c
│ │ ├── dwarf_getaranges.c
│ │ ├── dwarf_getattrcnt.c
│ │ ├── dwarf_getattrs.c
│ │ ├── dwarf_getcfi.c
│ │ ├── dwarf_getcfi_elf.c
│ │ ├── dwarf_getelf.c
│ │ ├── dwarf_getfuncs.c
│ │ ├── dwarf_getlocation.c
│ │ ├── dwarf_getlocation_attr.c
│ │ ├── dwarf_getlocation_die.c
│ │ ├── dwarf_getlocation_implicit_pointer.c
│ │ ├── dwarf_getmacros.c
│ │ ├── dwarf_getpubnames.c
│ │ ├── dwarf_getscopes.c
│ │ ├── dwarf_getscopes_die.c
│ │ ├── dwarf_getscopevar.c
│ │ ├── dwarf_getsrc_die.c
│ │ ├── dwarf_getsrc_file.c
│ │ ├── dwarf_getsrcdirs.c
│ │ ├── dwarf_getsrcfiles.c
│ │ ├── dwarf_getsrclines.c
│ │ ├── dwarf_getstring.c
│ │ ├── dwarf_hasattr.c
│ │ ├── dwarf_hasattr_integrate.c
│ │ ├── dwarf_haschildren.c
│ │ ├── dwarf_hasform.c
│ │ ├── dwarf_haspc.c
│ │ ├── dwarf_highpc.c
│ │ ├── dwarf_line_file.c
│ │ ├── dwarf_lineaddr.c
│ │ ├── dwarf_linebeginstatement.c
│ │ ├── dwarf_lineblock.c
│ │ ├── dwarf_linecol.c
│ │ ├── dwarf_linediscriminator.c
│ │ ├── dwarf_lineendsequence.c
│ │ ├── dwarf_lineepiloguebegin.c
│ │ ├── dwarf_lineisa.c
│ │ ├── dwarf_lineno.c
│ │ ├── dwarf_lineop_index.c
│ │ ├── dwarf_lineprologueend.c
│ │ ├── dwarf_linesrc.c
│ │ ├── dwarf_lowpc.c
│ │ ├── dwarf_macro_getparamcnt.c
│ │ ├── dwarf_macro_getsrcfiles.c
│ │ ├── dwarf_macro_opcode.c
│ │ ├── dwarf_macro_param.c
│ │ ├── dwarf_macro_param1.c
│ │ ├── dwarf_macro_param2.c
│ │ ├── dwarf_next_cfi.c
│ │ ├── dwarf_next_lines.c
│ │ ├── dwarf_nextcu.c
│ │ ├── dwarf_offabbrev.c
│ │ ├── dwarf_offdie.c
│ │ ├── dwarf_onearange.c
│ │ ├── dwarf_onesrcline.c
│ │ ├── dwarf_peel_type.c
│ │ ├── dwarf_ranges.c
│ │ ├── dwarf_setalt.c
│ │ ├── dwarf_siblingof.c
│ │ ├── dwarf_sig8_hash.c
│ │ ├── dwarf_sig8_hash.h
│ │ ├── dwarf_srclang.c
│ │ ├── dwarf_tag.c
│ │ ├── dwarf_whatattr.c
│ │ ├── dwarf_whatform.c
│ │ ├── encoded-value.h
│ │ ├── fde.c
│ │ ├── frame-cache.c
│ │ ├── known-dwarf.h
│ │ ├── libdw.h
│ │ ├── libdwP.h
│ │ ├── libdw_alloc.c
│ │ ├── libdw_find_split_unit.c
│ │ ├── libdw_findcu.c
│ │ ├── libdw_form.c
│ │ ├── libdw_visit_scopes.c
│ │ └── memory-access.h
│ ├── libdwelf/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── dwelf_dwarf_gnu_debugaltlink.c
│ │ ├── dwelf_elf_begin.c
│ │ ├── dwelf_elf_gnu_build_id.c
│ │ ├── dwelf_elf_gnu_debuglink.c
│ │ ├── dwelf_scn_gnu_compressed_size.c
│ │ ├── dwelf_strtab.c
│ │ ├── libdwelf.h
│ │ └── libdwelfP.h
│ ├── libdwfl/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── argp-std.c
│ │ ├── bzip2.c
│ │ ├── core-file.c
│ │ ├── cu.c
│ │ ├── derelocate.c
│ │ ├── dwfl_addrdie.c
│ │ ├── dwfl_addrdwarf.c
│ │ ├── dwfl_addrmodule.c
│ │ ├── dwfl_begin.c
│ │ ├── dwfl_build_id_find_debuginfo.c
│ │ ├── dwfl_build_id_find_elf.c
│ │ ├── dwfl_cumodule.c
│ │ ├── dwfl_dwarf_line.c
│ │ ├── dwfl_end.c
│ │ ├── dwfl_error.c
│ │ ├── dwfl_frame.c
│ │ ├── dwfl_frame_pc.c
│ │ ├── dwfl_frame_regs.c
│ │ ├── dwfl_getdwarf.c
│ │ ├── dwfl_getmodules.c
│ │ ├── dwfl_getsrc.c
│ │ ├── dwfl_getsrclines.c
│ │ ├── dwfl_line_comp_dir.c
│ │ ├── dwfl_linecu.c
│ │ ├── dwfl_lineinfo.c
│ │ ├── dwfl_linemodule.c
│ │ ├── dwfl_module.c
│ │ ├── dwfl_module_addrdie.c
│ │ ├── dwfl_module_addrname.c
│ │ ├── dwfl_module_addrsym.c
│ │ ├── dwfl_module_build_id.c
│ │ ├── dwfl_module_dwarf_cfi.c
│ │ ├── dwfl_module_eh_cfi.c
│ │ ├── dwfl_module_getdwarf.c
│ │ ├── dwfl_module_getelf.c
│ │ ├── dwfl_module_getsrc.c
│ │ ├── dwfl_module_getsrc_file.c
│ │ ├── dwfl_module_getsym.c
│ │ ├── dwfl_module_info.c
│ │ ├── dwfl_module_nextcu.c
│ │ ├── dwfl_module_register_names.c
│ │ ├── dwfl_module_report_build_id.c
│ │ ├── dwfl_module_return_value_location.c
│ │ ├── dwfl_nextcu.c
│ │ ├── dwfl_onesrcline.c
│ │ ├── dwfl_report_elf.c
│ │ ├── dwfl_segment_report_module.c
│ │ ├── dwfl_validate_address.c
│ │ ├── dwfl_version.c
│ │ ├── elf-from-memory.c
│ │ ├── find-debuginfo.c
│ │ ├── frame_unwind.c
│ │ ├── gzip.c
│ │ ├── image-header.c
│ │ ├── libdwfl.h
│ │ ├── libdwflP.h
│ │ ├── libdwfl_crc32.c
│ │ ├── libdwfl_crc32_file.c
│ │ ├── lines.c
│ │ ├── link_map.c
│ │ ├── linux-core-attach.c
│ │ ├── linux-kernel-modules.c
│ │ ├── linux-pid-attach.c
│ │ ├── linux-proc-maps.c
│ │ ├── lzma.c
│ │ ├── offline.c
│ │ ├── open.c
│ │ ├── relocate.c
│ │ └── segment.c
│ ├── libebl/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── ebl-hooks.h
│ │ ├── ebl_check_special_section.c
│ │ ├── ebl_check_special_symbol.c
│ │ ├── ebl_data_marker_symbol.c
│ │ ├── ebl_syscall_abi.c
│ │ ├── eblabicfi.c
│ │ ├── eblauxvinfo.c
│ │ ├── eblbackendname.c
│ │ ├── eblbsspltp.c
│ │ ├── eblcheckobjattr.c
│ │ ├── eblcheckreloctargettype.c
│ │ ├── eblclosebackend.c
│ │ ├── eblcopyrelocp.c
│ │ ├── eblcorenote.c
│ │ ├── eblcorenotetypename.c
│ │ ├── ebldebugscnp.c
│ │ ├── ebldwarftoregno.c
│ │ ├── ebldynamictagcheck.c
│ │ ├── ebldynamictagname.c
│ │ ├── eblelfclass.c
│ │ ├── eblelfdata.c
│ │ ├── eblelfmachine.c
│ │ ├── eblgotpcreloccheck.c
│ │ ├── eblinitreg.c
│ │ ├── eblmachineflagcheck.c
│ │ ├── eblmachineflagname.c
│ │ ├── eblmachinesectionflagcheck.c
│ │ ├── eblnonerelocp.c
│ │ ├── eblnormalizepc.c
│ │ ├── eblobjnote.c
│ │ ├── eblobjnotetypename.c
│ │ ├── eblopenbackend.c
│ │ ├── eblosabiname.c
│ │ ├── eblreginfo.c
│ │ ├── eblrelativerelocp.c
│ │ ├── eblrelocsimpletype.c
│ │ ├── eblreloctypecheck.c
│ │ ├── eblreloctypename.c
│ │ ├── eblrelocvaliduse.c
│ │ ├── eblresolvesym.c
│ │ ├── eblretval.c
│ │ ├── eblsectionname.c
│ │ ├── eblsectionstripp.c
│ │ ├── eblsectiontypename.c
│ │ ├── eblsegmenttypename.c
│ │ ├── eblstother.c
│ │ ├── eblsymbolbindingname.c
│ │ ├── eblsymboltypename.c
│ │ ├── eblsysvhashentrysize.c
│ │ ├── eblunwind.c
│ │ ├── libebl.h
│ │ └── libeblP.h
│ ├── libelf/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── abstract.h
│ │ ├── chdr_xlate.h
│ │ ├── common.h
│ │ ├── dl-hash.h
│ │ ├── elf-knowledge.h
│ │ ├── elf.h
│ │ ├── elf32_checksum.c
│ │ ├── elf32_fsize.c
│ │ ├── elf32_getchdr.c
│ │ ├── elf32_getehdr.c
│ │ ├── elf32_getphdr.c
│ │ ├── elf32_getshdr.c
│ │ ├── elf32_newehdr.c
│ │ ├── elf32_newphdr.c
│ │ ├── elf32_offscn.c
│ │ ├── elf32_updatefile.c
│ │ ├── elf32_updatenull.c
│ │ ├── elf32_xlatetof.c
│ │ ├── elf32_xlatetom.c
│ │ ├── elf64_checksum.c
│ │ ├── elf64_fsize.c
│ │ ├── elf64_getchdr.c
│ │ ├── elf64_getehdr.c
│ │ ├── elf64_getphdr.c
│ │ ├── elf64_getshdr.c
│ │ ├── elf64_newehdr.c
│ │ ├── elf64_newphdr.c
│ │ ├── elf64_offscn.c
│ │ ├── elf64_updatefile.c
│ │ ├── elf64_updatenull.c
│ │ ├── elf64_xlatetof.c
│ │ ├── elf64_xlatetom.c
│ │ ├── elf_begin.c
│ │ ├── elf_clone.c
│ │ ├── elf_cntl.c
│ │ ├── elf_compress.c
│ │ ├── elf_compress_gnu.c
│ │ ├── elf_end.c
│ │ ├── elf_error.c
│ │ ├── elf_fill.c
│ │ ├── elf_flagdata.c
│ │ ├── elf_flagehdr.c
│ │ ├── elf_flagelf.c
│ │ ├── elf_flagphdr.c
│ │ ├── elf_flagscn.c
│ │ ├── elf_flagshdr.c
│ │ ├── elf_getarhdr.c
│ │ ├── elf_getaroff.c
│ │ ├── elf_getarsym.c
│ │ ├── elf_getbase.c
│ │ ├── elf_getdata.c
│ │ ├── elf_getdata_rawchunk.c
│ │ ├── elf_getident.c
│ │ ├── elf_getphdrnum.c
│ │ ├── elf_getscn.c
│ │ ├── elf_getshdrnum.c
│ │ ├── elf_getshdrstrndx.c
│ │ ├── elf_gnu_hash.c
│ │ ├── elf_hash.c
│ │ ├── elf_kind.c
│ │ ├── elf_memory.c
│ │ ├── elf_ndxscn.c
│ │ ├── elf_newdata.c
│ │ ├── elf_newscn.c
│ │ ├── elf_next.c
│ │ ├── elf_nextscn.c
│ │ ├── elf_rand.c
│ │ ├── elf_rawdata.c
│ │ ├── elf_rawfile.c
│ │ ├── elf_readall.c
│ │ ├── elf_scnshndx.c
│ │ ├── elf_strptr.c
│ │ ├── elf_update.c
│ │ ├── elf_version.c
│ │ ├── exttypes.h
│ │ ├── gelf.h
│ │ ├── gelf_checksum.c
│ │ ├── gelf_fsize.c
│ │ ├── gelf_getauxv.c
│ │ ├── gelf_getchdr.c
│ │ ├── gelf_getclass.c
│ │ ├── gelf_getdyn.c
│ │ ├── gelf_getehdr.c
│ │ ├── gelf_getlib.c
│ │ ├── gelf_getmove.c
│ │ ├── gelf_getnote.c
│ │ ├── gelf_getphdr.c
│ │ ├── gelf_getrel.c
│ │ ├── gelf_getrela.c
│ │ ├── gelf_getshdr.c
│ │ ├── gelf_getsym.c
│ │ ├── gelf_getsyminfo.c
│ │ ├── gelf_getsymshndx.c
│ │ ├── gelf_getverdaux.c
│ │ ├── gelf_getverdef.c
│ │ ├── gelf_getvernaux.c
│ │ ├── gelf_getverneed.c
│ │ ├── gelf_getversym.c
│ │ ├── gelf_newehdr.c
│ │ ├── gelf_newphdr.c
│ │ ├── gelf_offscn.c
│ │ ├── gelf_update_auxv.c
│ │ ├── gelf_update_dyn.c
│ │ ├── gelf_update_ehdr.c
│ │ ├── gelf_update_lib.c
│ │ ├── gelf_update_move.c
│ │ ├── gelf_update_phdr.c
│ │ ├── gelf_update_rel.c
│ │ ├── gelf_update_rela.c
│ │ ├── gelf_update_shdr.c
│ │ ├── gelf_update_sym.c
│ │ ├── gelf_update_syminfo.c
│ │ ├── gelf_update_symshndx.c
│ │ ├── gelf_update_verdaux.c
│ │ ├── gelf_update_verdef.c
│ │ ├── gelf_update_vernaux.c
│ │ ├── gelf_update_verneed.c
│ │ ├── gelf_update_versym.c
│ │ ├── gelf_xlate.c
│ │ ├── gelf_xlate.h
│ │ ├── gelf_xlatetof.c
│ │ ├── gelf_xlatetom.c
│ │ ├── gnuhash_xlate.h
│ │ ├── libelf.h
│ │ ├── libelfP.h
│ │ ├── libelf_crc32.c
│ │ ├── libelf_next_prime.c
│ │ ├── nlist.c
│ │ ├── nlist.h
│ │ ├── note_xlate.h
│ │ └── version_xlate.h
│ ├── m4/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── biarch.m4
│ │ ├── codeset.m4
│ │ ├── gettext.m4
│ │ ├── iconv.m4
│ │ ├── lcmessage.m4
│ │ ├── nls.m4
│ │ ├── po.m4
│ │ ├── progtest.m4
│ │ └── zip.m4
│ ├── po/
│ │ ├── ChangeLog
│ │ ├── LINGUAS
│ │ ├── Makefile.in.in
│ │ ├── Makevars
│ │ ├── POTFILES.in
│ │ ├── Rules-quot
│ │ ├── boldquot.sed
│ │ ├── de.gmo
│ │ ├── de.po
│ │ ├── elfutils.pot
│ │ ├── en@boldquot.gmo
│ │ ├── en@boldquot.header
│ │ ├── en@boldquot.po
│ │ ├── en@quot.gmo
│ │ ├── en@quot.header
│ │ ├── en@quot.po
│ │ ├── es.gmo
│ │ ├── es.po
│ │ ├── insert-header.sin
│ │ ├── ja.gmo
│ │ ├── ja.po
│ │ ├── pl.gmo
│ │ ├── pl.po
│ │ ├── quot.sed
│ │ ├── remove-potcdate.sin
│ │ ├── stamp-po
│ │ ├── uk.gmo
│ │ └── uk.po
│ ├── src/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── addr2line.c
│ │ ├── ar.c
│ │ ├── arlib-argp.c
│ │ ├── arlib.c
│ │ ├── arlib.h
│ │ ├── arlib2.c
│ │ ├── debugpred.h
│ │ ├── elfcmp.c
│ │ ├── elfcompress.c
│ │ ├── elflint.c
│ │ ├── findtextrel.c
│ │ ├── make-debug-archive.in
│ │ ├── nm.c
│ │ ├── objdump.c
│ │ ├── ranlib.c
│ │ ├── readelf.c
│ │ ├── size.c
│ │ ├── stack.c
│ │ ├── strings.c
│ │ ├── strip.c
│ │ └── unstrip.c
│ ├── tests/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── addrcfi.c
│ │ ├── addrscopes.c
│ │ ├── addrx_constx-4.dwo.bz2
│ │ ├── addrx_constx-5.dwo.bz2
│ │ ├── addsections.c
│ │ ├── aggregate_size.c
│ │ ├── all-dwarf-ranges.c
│ │ ├── alldts.c
│ │ ├── allfcts.c
│ │ ├── allregs.c
│ │ ├── arextract.c
│ │ ├── arls.c
│ │ ├── arsymtest.c
│ │ ├── asm-tst1.c
│ │ ├── asm-tst2.c
│ │ ├── asm-tst3.c
│ │ ├── asm-tst4.c
│ │ ├── asm-tst5.c
│ │ ├── asm-tst6.c
│ │ ├── asm-tst7.c
│ │ ├── asm-tst8.c
│ │ ├── asm-tst9.c
│ │ ├── attr-integrate-skel.c
│ │ ├── backtrace-child.c
│ │ ├── backtrace-data.c
│ │ ├── backtrace-dwarf.c
│ │ ├── backtrace-subr.sh
│ │ ├── backtrace.aarch64.core.bz2
│ │ ├── backtrace.aarch64.exec.bz2
│ │ ├── backtrace.aarch64.fp.core.bz2
│ │ ├── backtrace.aarch64.fp.exec.bz2
│ │ ├── backtrace.c
│ │ ├── backtrace.i386.core.bz2
│ │ ├── backtrace.i386.exec.bz2
│ │ ├── backtrace.i386.fp.core.bz2
│ │ ├── backtrace.i386.fp.exec.bz2
│ │ ├── backtrace.ppc.core.bz2
│ │ ├── backtrace.ppc.exec.bz2
│ │ ├── backtrace.ppc64le.fp.core.bz2
│ │ ├── backtrace.ppc64le.fp.exec.bz2
│ │ ├── backtrace.s390.core.bz2
│ │ ├── backtrace.s390.exec.bz2
│ │ ├── backtrace.s390x.core.bz2
│ │ ├── backtrace.s390x.exec.bz2
│ │ ├── backtrace.sparc.core.bz2
│ │ ├── backtrace.sparc.exec.bz2
│ │ ├── backtrace.x32.core.bz2
│ │ ├── backtrace.x32.exec.bz2
│ │ ├── backtrace.x86_64.core.bz2
│ │ ├── backtrace.x86_64.exec.bz2
│ │ ├── backtrace.x86_64.fp.core.bz2
│ │ ├── backtrace.x86_64.fp.exec.bz2
│ │ ├── buildid.c
│ │ ├── cleanup-13.c
│ │ ├── coverage.sh
│ │ ├── debug-ranges-no-lowpc.o.bz2
│ │ ├── debugaltlink.c
│ │ ├── debuglink.c
│ │ ├── deleted-lib.c
│ │ ├── deleted.c
│ │ ├── dwarf-die-addr-die.c
│ │ ├── dwarf-getmacros.c
│ │ ├── dwarf-getstring.c
│ │ ├── dwarf-ranges.c
│ │ ├── dwarf_default_lower_bound.c
│ │ ├── dwarfcfi.c
│ │ ├── dwelfgnucompressed.c
│ │ ├── dwfl-addr-sect.c
│ │ ├── dwfl-bug-addr-overflow.c
│ │ ├── dwfl-bug-fd-leak.c
│ │ ├── dwfl-bug-getmodules.c
│ │ ├── dwfl-bug-report.c
│ │ ├── dwfl-proc-attach.c
│ │ ├── dwfl-report-elf-align.c
│ │ ├── dwfllines.c
│ │ ├── dwflmodtest.c
│ │ ├── dwflsyms.c
│ │ ├── early-offscn.c
│ │ ├── ecp.c
│ │ ├── elfcopy.c
│ │ ├── elfgetchdr.c
│ │ ├── elfgetzdata.c
│ │ ├── elfputzdata.c
│ │ ├── elfshphehdr.c
│ │ ├── elfstrmerge.c
│ │ ├── elfstrtab.c
│ │ ├── emptyfile.c
│ │ ├── fillfile.c
│ │ ├── find-prologues.c
│ │ ├── funcretval.c
│ │ ├── funcretval_test.c
│ │ ├── funcretval_test_aarch64.bz2
│ │ ├── funcscopes.c
│ │ ├── get-aranges.c
│ │ ├── get-files.c
│ │ ├── get-lines.c
│ │ ├── get-pubnames.c
│ │ ├── get-units-invalid.c
│ │ ├── get-units-split.c
│ │ ├── getsrc_die.c
│ │ ├── hash.c
│ │ ├── hello_aarch64.ko.bz2
│ │ ├── hello_i386.ko.bz2
│ │ ├── hello_m68k.ko.bz2
│ │ ├── hello_ppc64.ko.bz2
│ │ ├── hello_riscv64.ko.bz2
│ │ ├── hello_s390.ko.bz2
│ │ ├── hello_x86_64.ko.bz2
│ │ ├── lfs-symbols
│ │ ├── libtestfile_multi_shared.so.bz2
│ │ ├── line2addr.c
│ │ ├── linkmap-cut-lib.so.bz2
│ │ ├── linkmap-cut.bz2
│ │ ├── linkmap-cut.core.bz2
│ │ ├── low_high_pc.c
│ │ ├── msg_tst.c
│ │ ├── newdata.c
│ │ ├── newfile.c
│ │ ├── newscn.c
│ │ ├── next-files.c
│ │ ├── next-lines.c
│ │ ├── next_cfi.c
│ │ ├── peel_type.c
│ │ ├── rdwrmmap.c
│ │ ├── rerequest_tag.c
│ │ ├── run-addr2line-alt-debugpath.sh
│ │ ├── run-addr2line-i-demangle-test.sh
│ │ ├── run-addr2line-i-lex-test.sh
│ │ ├── run-addr2line-i-test.sh
│ │ ├── run-addr2line-test.sh
│ │ ├── run-addrcfi.sh
│ │ ├── run-addrname-test.sh
│ │ ├── run-addrscopes.sh
│ │ ├── run-aggregate-size.sh
│ │ ├── run-all-dwarf-ranges.sh
│ │ ├── run-alldts.sh
│ │ ├── run-allfcts-multi.sh
│ │ ├── run-allfcts.sh
│ │ ├── run-allregs.sh
│ │ ├── run-annobingroup.sh
│ │ ├── run-ar.sh
│ │ ├── run-arextract.sh
│ │ ├── run-arsymtest.sh
│ │ ├── run-attr-integrate-skel.sh
│ │ ├── run-backtrace-core-aarch64.sh
│ │ ├── run-backtrace-core-i386.sh
│ │ ├── run-backtrace-core-ppc.sh
│ │ ├── run-backtrace-core-s390.sh
│ │ ├── run-backtrace-core-s390x.sh
│ │ ├── run-backtrace-core-sparc.sh
│ │ ├── run-backtrace-core-x32.sh
│ │ ├── run-backtrace-core-x86_64.sh
│ │ ├── run-backtrace-data.sh
│ │ ├── run-backtrace-demangle.sh
│ │ ├── run-backtrace-dwarf.sh
│ │ ├── run-backtrace-fp-core-aarch64.sh
│ │ ├── run-backtrace-fp-core-i386.sh
│ │ ├── run-backtrace-fp-core-ppc64le.sh
│ │ ├── run-backtrace-fp-core-x86_64.sh
│ │ ├── run-backtrace-native-biarch.sh
│ │ ├── run-backtrace-native-core-biarch.sh
│ │ ├── run-backtrace-native-core.sh
│ │ ├── run-backtrace-native.sh
│ │ ├── run-bug1-test.sh
│ │ ├── run-buildid.sh
│ │ ├── run-compress-test.sh
│ │ ├── run-copyadd-sections.sh
│ │ ├── run-copymany-sections.sh
│ │ ├── run-debugaltlink.sh
│ │ ├── run-debuglink.sh
│ │ ├── run-deleted.sh
│ │ ├── run-disasm-bpf.sh
│ │ ├── run-disasm-x86-64.sh
│ │ ├── run-disasm-x86.sh
│ │ ├── run-dwarf-die-addr-die.sh
│ │ ├── run-dwarf-getmacros.sh
│ │ ├── run-dwarf-getstring.sh
│ │ ├── run-dwarf-ranges.sh
│ │ ├── run-dwarfcfi.sh
│ │ ├── run-dwelfgnucompressed.sh
│ │ ├── run-dwfl-addr-sect.sh
│ │ ├── run-dwfl-bug-offline-rel.sh
│ │ ├── run-dwfl-report-elf-align.sh
│ │ ├── run-dwfllines.sh
│ │ ├── run-dwflsyms.sh
│ │ ├── run-early-offscn.sh
│ │ ├── run-ecp-test.sh
│ │ ├── run-ecp-test2.sh
│ │ ├── run-elf_cntl_gelf_getshdr.sh
│ │ ├── run-elfgetchdr.sh
│ │ ├── run-elfgetzdata.sh
│ │ ├── run-elflint-self.sh
│ │ ├── run-elflint-test.sh
│ │ ├── run-elfputzdata.sh
│ │ ├── run-elfstrmerge-test.sh
│ │ ├── run-exprlocs-self.sh
│ │ ├── run-exprlocs.sh
│ │ ├── run-find-prologues.sh
│ │ ├── run-funcretval.sh
│ │ ├── run-funcscopes.sh
│ │ ├── run-get-aranges.sh
│ │ ├── run-get-files.sh
│ │ ├── run-get-lines.sh
│ │ ├── run-get-pubnames.sh
│ │ ├── run-get-units-invalid.sh
│ │ ├── run-get-units-split.sh
│ │ ├── run-getsrc-die.sh
│ │ ├── run-lfs-symbols.sh
│ │ ├── run-line2addr.sh
│ │ ├── run-linkmap-cut.sh
│ │ ├── run-low_high_pc.sh
│ │ ├── run-macro-test.sh
│ │ ├── run-native-test.sh
│ │ ├── run-next-cfi-self.sh
│ │ ├── run-next-cfi.sh
│ │ ├── run-next-files.sh
│ │ ├── run-next-lines.sh
│ │ ├── run-nm-self.sh
│ │ ├── run-peel-type.sh
│ │ ├── run-prelink-addr-test.sh
│ │ ├── run-ranlib-test.sh
│ │ ├── run-ranlib-test2.sh
│ │ ├── run-ranlib-test3.sh
│ │ ├── run-ranlib-test4.sh
│ │ ├── run-readelf-A.sh
│ │ ├── run-readelf-addr.sh
│ │ ├── run-readelf-aranges.sh
│ │ ├── run-readelf-compressed.sh
│ │ ├── run-readelf-const-values.sh
│ │ ├── run-readelf-d.sh
│ │ ├── run-readelf-dwz-multi.sh
│ │ ├── run-readelf-gdb_index.sh
│ │ ├── run-readelf-info-plus.sh
│ │ ├── run-readelf-line.sh
│ │ ├── run-readelf-loc.sh
│ │ ├── run-readelf-macro.sh
│ │ ├── run-readelf-mixed-corenote.sh
│ │ ├── run-readelf-n.sh
│ │ ├── run-readelf-ranges.sh
│ │ ├── run-readelf-s.sh
│ │ ├── run-readelf-self.sh
│ │ ├── run-readelf-str.sh
│ │ ├── run-readelf-test1.sh
│ │ ├── run-readelf-test2.sh
│ │ ├── run-readelf-test3.sh
│ │ ├── run-readelf-test4.sh
│ │ ├── run-readelf-twofiles.sh
│ │ ├── run-readelf-types.sh
│ │ ├── run-readelf-variant.sh
│ │ ├── run-readelf-vmcoreinfo.sh
│ │ ├── run-readelf-z.sh
│ │ ├── run-readelf-zdebug-rel.sh
│ │ ├── run-readelf-zdebug.sh
│ │ ├── run-readelf-zp.sh
│ │ ├── run-readelf-zx.sh
│ │ ├── run-reloc-bpf.sh
│ │ ├── run-rerequest_tag.sh
│ │ ├── run-show-abbrev.sh
│ │ ├── run-show-die-info.sh
│ │ ├── run-stack-d-test.sh
│ │ ├── run-stack-demangled-test.sh
│ │ ├── run-stack-i-test.sh
│ │ ├── run-strings-test.sh
│ │ ├── run-strip-g.sh
│ │ ├── run-strip-groups.sh
│ │ ├── run-strip-nobitsalign.sh
│ │ ├── run-strip-nothing.sh
│ │ ├── run-strip-reloc.sh
│ │ ├── run-strip-remove-keep.sh
│ │ ├── run-strip-strmerge.sh
│ │ ├── run-strip-test-many.sh
│ │ ├── run-strip-test.sh
│ │ ├── run-strip-test10.sh
│ │ ├── run-strip-test11.sh
│ │ ├── run-strip-test12.sh
│ │ ├── run-strip-test2.sh
│ │ ├── run-strip-test3.sh
│ │ ├── run-strip-test4.sh
│ │ ├── run-strip-test5.sh
│ │ ├── run-strip-test6.sh
│ │ ├── run-strip-test7.sh
│ │ ├── run-strip-test8.sh
│ │ ├── run-strip-test9.sh
│ │ ├── run-strip-version.sh
│ │ ├── run-strptr.sh
│ │ ├── run-test-archive64.sh
│ │ ├── run-test-flag-nobits.sh
│ │ ├── run-typeiter-many.sh
│ │ ├── run-typeiter.sh
│ │ ├── run-unit-info.sh
│ │ ├── run-unstrip-M.sh
│ │ ├── run-unstrip-n.sh
│ │ ├── run-unstrip-test.sh
│ │ ├── run-unstrip-test2.sh
│ │ ├── run-unstrip-test3.sh
│ │ ├── run-unstrip-test4.sh
│ │ ├── run-varlocs-self.sh
│ │ ├── run-varlocs.sh
│ │ ├── run-zstrptr.sh
│ │ ├── saridx.c
│ │ ├── scnnames.c
│ │ ├── sectiondump.c
│ │ ├── show-abbrev.c
│ │ ├── show-die-info.c
│ │ ├── showptable.c
│ │ ├── splitdwarf4-not-split4.dwo.bz2
│ │ ├── strptr.c
│ │ ├── system-elf-libelf-test.c
│ │ ├── test-core-lib.so.bz2
│ │ ├── test-core.core.bz2
│ │ ├── test-core.exec.bz2
│ │ ├── test-elf_cntl_gelf_getshdr.c
│ │ ├── test-flag-nobits.c
│ │ ├── test-nlist.c
│ │ ├── test-offset-loop.alt.bz2
│ │ ├── test-offset-loop.bz2
│ │ ├── test-subr.sh
│ │ ├── test-wrapper.sh
│ │ ├── testarchive64.a.bz2
│ │ ├── testcore-rtlib-ppc.bz2
│ │ ├── testcore-rtlib.bz2
│ │ ├── testfile-ada-variant.bz2
│ │ ├── testfile-addrx_constx-4.bz2
│ │ ├── testfile-addrx_constx-5.bz2
│ │ ├── testfile-annobingroup-i386.o.bz2
│ │ ├── testfile-annobingroup-x86_64.o.bz2
│ │ ├── testfile-annobingroup.o.bz2
│ │ ├── testfile-backtrace-demangle.bz2
│ │ ├── testfile-backtrace-demangle.cc
│ │ ├── testfile-backtrace-demangle.core.bz2
│ │ ├── testfile-bpf-dis1.expect.bz2
│ │ ├── testfile-bpf-dis1.o.bz2
│ │ ├── testfile-bpf-reloc.expect.bz2
│ │ ├── testfile-bpf-reloc.o.bz2
│ │ ├── testfile-const-values.debug.bz2
│ │ ├── testfile-debug-rel-g.o.bz2
│ │ ├── testfile-debug-rel-ppc64-g.o.bz2
│ │ ├── testfile-debug-rel-ppc64-z.o.bz2
│ │ ├── testfile-debug-rel-ppc64.o.bz2
│ │ ├── testfile-debug-rel-z.o.bz2
│ │ ├── testfile-debug-rel.o.bz2
│ │ ├── testfile-debug-types.bz2
│ │ ├── testfile-debug.bz2
│ │ ├── testfile-dwarf-4.bz2
│ │ ├── testfile-dwarf-45.source
│ │ ├── testfile-dwarf-5.bz2
│ │ ├── testfile-dwfl-report-elf-align-shlib.so.bz2
│ │ ├── testfile-dwzstr.bz2
│ │ ├── testfile-dwzstr.multi.bz2
│ │ ├── testfile-gnu-property-note.bz2
│ │ ├── testfile-gnu-property-note.o.bz2
│ │ ├── testfile-hello4.dwo.bz2
│ │ ├── testfile-hello5.dwo.bz2
│ │ ├── testfile-info-link.bz2
│ │ ├── testfile-info-link.debuginfo.bz2
│ │ ├── testfile-info-link.stripped.bz2
│ │ ├── testfile-inlines.bz2
│ │ ├── testfile-lex-inlines.bz2
│ │ ├── testfile-m68k-core.bz2
│ │ ├── testfile-m68k-s.bz2
│ │ ├── testfile-m68k.bz2
│ │ ├── testfile-macinfo.bz2
│ │ ├── testfile-macros-0xff.bz2
│ │ ├── testfile-macros.bz2
│ │ ├── testfile-nobitsalign.bz2
│ │ ├── testfile-nobitsalign.strip.bz2
│ │ ├── testfile-nolfs.bz2
│ │ ├── testfile-only-debug-line.bz2
│ │ ├── testfile-ppc64-min-instr.bz2
│ │ ├── testfile-ranges-hello.dwo.bz2
│ │ ├── testfile-ranges-hello5.dwo.bz2
│ │ ├── testfile-ranges-world.dwo.bz2
│ │ ├── testfile-ranges-world5.dwo.bz2
│ │ ├── testfile-riscv64-core.bz2
│ │ ├── testfile-riscv64-s.bz2
│ │ ├── testfile-riscv64.bz2
│ │ ├── testfile-s390x-hash-both.bz2
│ │ ├── testfile-sizes1.o.bz2
│ │ ├── testfile-sizes2.o.bz2
│ │ ├── testfile-sizes3.o.bz2
│ │ ├── testfile-sizes4.o.bz2
│ │ ├── testfile-sizes4.s
│ │ ├── testfile-splitdwarf-4.bz2
│ │ ├── testfile-splitdwarf-5.bz2
│ │ ├── testfile-splitdwarf4-not-split4.debug.bz2
│ │ ├── testfile-stridex.bz2
│ │ ├── testfile-strtab.bz2
│ │ ├── testfile-strtab.debuginfo.bz2
│ │ ├── testfile-strtab.stripped.bz2
│ │ ├── testfile-version.bz2
│ │ ├── testfile-world4.dwo.bz2
│ │ ├── testfile-world5.dwo.bz2
│ │ ├── testfile-x32-core.bz2
│ │ ├── testfile-x32-d.bz2
│ │ ├── testfile-x32-debug.bz2
│ │ ├── testfile-x32-s.bz2
│ │ ├── testfile-x32.bz2
│ │ ├── testfile-zdebug.bz2
│ │ ├── testfile-zgabi32.bz2
│ │ ├── testfile-zgabi32be.bz2
│ │ ├── testfile-zgabi64.bz2
│ │ ├── testfile-zgabi64be.bz2
│ │ ├── testfile-zgnu32.bz2
│ │ ├── testfile-zgnu32be.bz2
│ │ ├── testfile-zgnu64.bz2
│ │ ├── testfile-zgnu64be.bz2
│ │ ├── testfile.bz2
│ │ ├── testfile10.bz2
│ │ ├── testfile11-debugframe.bz2
│ │ ├── testfile11.bz2
│ │ ├── testfile12-debugframe.bz2
│ │ ├── testfile12.bz2
│ │ ├── testfile13.bz2
│ │ ├── testfile14.bz2
│ │ ├── testfile15.bz2
│ │ ├── testfile15.debug.bz2
│ │ ├── testfile16.bz2
│ │ ├── testfile16.debug.bz2
│ │ ├── testfile17.bz2
│ │ ├── testfile17.debug.bz2
│ │ ├── testfile18.bz2
│ │ ├── testfile19.bz2
│ │ ├── testfile19.index.bz2
│ │ ├── testfile2.bz2
│ │ ├── testfile20.bz2
│ │ ├── testfile20.index.bz2
│ │ ├── testfile21.bz2
│ │ ├── testfile21.index.bz2
│ │ ├── testfile22.bz2
│ │ ├── testfile23.bz2
│ │ ├── testfile24.bz2
│ │ ├── testfile25.bz2
│ │ ├── testfile26.bz2
│ │ ├── testfile27.bz2
│ │ ├── testfile28.bz2
│ │ ├── testfile28.rdwr.bz2
│ │ ├── testfile29.bz2
│ │ ├── testfile29.rdwr.bz2
│ │ ├── testfile3.bz2
│ │ ├── testfile30.bz2
│ │ ├── testfile31.bz2
│ │ ├── testfile32.bz2
│ │ ├── testfile33.bz2
│ │ ├── testfile34.bz2
│ │ ├── testfile35.bz2
│ │ ├── testfile35.debug.bz2
│ │ ├── testfile36.bz2
│ │ ├── testfile36.debug.bz2
│ │ ├── testfile37.bz2
│ │ ├── testfile37.debug.bz2
│ │ ├── testfile38.bz2
│ │ ├── testfile39.bz2
│ │ ├── testfile4.bz2
│ │ ├── testfile40.bz2
│ │ ├── testfile40.debug.bz2
│ │ ├── testfile41.bz2
│ │ ├── testfile42.bz2
│ │ ├── testfile42_noshdrs.bz2
│ │ ├── testfile43.bz2
│ │ ├── testfile44.S.bz2
│ │ ├── testfile44.expect.bz2
│ │ ├── testfile45.S.bz2
│ │ ├── testfile45.expect.bz2
│ │ ├── testfile46.bz2
│ │ ├── testfile47.bz2
│ │ ├── testfile48.bz2
│ │ ├── testfile48.debug.bz2
│ │ ├── testfile49.bz2
│ │ ├── testfile5.bz2
│ │ ├── testfile50.bz2
│ │ ├── testfile51.bz2
│ │ ├── testfile52-32.noshdrs.so.bz2
│ │ ├── testfile52-32.prelink.so.bz2
│ │ ├── testfile52-32.so.bz2
│ │ ├── testfile52-32.so.debug.bz2
│ │ ├── testfile52-64.noshdrs.so.bz2
│ │ ├── testfile52-64.prelink.so.bz2
│ │ ├── testfile52-64.so.bz2
│ │ ├── testfile52-64.so.debug.bz2
│ │ ├── testfile53-32.bz2
│ │ ├── testfile53-32.debug.bz2
│ │ ├── testfile53-32.prelink.bz2
│ │ ├── testfile53-64.bz2
│ │ ├── testfile53-64.debug.bz2
│ │ ├── testfile53-64.prelink.bz2
│ │ ├── testfile54-32.noshdrs.so.bz2
│ │ ├── testfile54-32.prelink.so.bz2
│ │ ├── testfile54-32.so.bz2
│ │ ├── testfile54-32.so.debug.bz2
│ │ ├── testfile54-64.noshdrs.so.bz2
│ │ ├── testfile54-64.prelink.so.bz2
│ │ ├── testfile54-64.so.bz2
│ │ ├── testfile54-64.so.debug.bz2
│ │ ├── testfile55-32.bz2
│ │ ├── testfile55-32.debug.bz2
│ │ ├── testfile55-32.prelink.bz2
│ │ ├── testfile55-64.bz2
│ │ ├── testfile55-64.debug.bz2
│ │ ├── testfile55-64.prelink.bz2
│ │ ├── testfile56.bz2
│ │ ├── testfile57.bz2
│ │ ├── testfile58.bz2
│ │ ├── testfile59.bz2
│ │ ├── testfile6.bz2
│ │ ├── testfile60.bz2
│ │ ├── testfile61.bz2
│ │ ├── testfile62.bz2
│ │ ├── testfile63.bz2
│ │ ├── testfile64.bz2
│ │ ├── testfile65.bz2
│ │ ├── testfile66.bz2
│ │ ├── testfile66.core.bz2
│ │ ├── testfile67.bz2
│ │ ├── testfile68.bz2
│ │ ├── testfile69.core.bz2
│ │ ├── testfile69.so.bz2
│ │ ├── testfile7.bz2
│ │ ├── testfile70.core.bz2
│ │ ├── testfile70.exec.bz2
│ │ ├── testfile71.bz2
│ │ ├── testfile8.bz2
│ │ ├── testfile9.bz2
│ │ ├── testfile_aarch64_core.bz2
│ │ ├── testfile_class_func.bz2
│ │ ├── testfile_const_type.bz2
│ │ ├── testfile_const_type.c
│ │ ├── testfile_entry_value.bz2
│ │ ├── testfile_entry_value.c
│ │ ├── testfile_gnu_props.32be.o.bz2
│ │ ├── testfile_gnu_props.32le.o.bz2
│ │ ├── testfile_gnu_props.64be.o.bz2
│ │ ├── testfile_gnu_props.64le.o.bz2
│ │ ├── testfile_i686_core.bz2
│ │ ├── testfile_implicit_pointer.bz2
│ │ ├── testfile_implicit_pointer.c
│ │ ├── testfile_implicit_value.bz2
│ │ ├── testfile_implicit_value.c
│ │ ├── testfile_low_high_pc.bz2
│ │ ├── testfile_multi.dwz.bz2
│ │ ├── testfile_multi_main.bz2
│ │ ├── testfile_nested_funcs.bz2
│ │ ├── testfile_parameter_ref.bz2
│ │ ├── testfile_parameter_ref.c
│ │ ├── testfileaarch64-debugframe.bz2
│ │ ├── testfileaarch64.bz2
│ │ ├── testfilearm-debugframe.bz2
│ │ ├── testfilearm.bz2
│ │ ├── testfilebasmin.bz2
│ │ ├── testfilebaxmin.bz2
│ │ ├── testfilebazdbg.bz2
│ │ ├── testfilebazdbg.debug.bz2
│ │ ├── testfilebazdbg_pl.bz2
│ │ ├── testfilebazdbg_plr.bz2
│ │ ├── testfilebazdbgppc64.bz2
│ │ ├── testfilebazdbgppc64.debug.bz2
│ │ ├── testfilebazdbgppc64_pl.bz2
│ │ ├── testfilebazdbgppc64_plr.bz2
│ │ ├── testfilebazdyn.bz2
│ │ ├── testfilebazdynppc64.bz2
│ │ ├── testfilebazmdb.bz2
│ │ ├── testfilebazmdbppc64.bz2
│ │ ├── testfilebazmin.bz2
│ │ ├── testfilebazmin_pl.bz2
│ │ ├── testfilebazmin_plr.bz2
│ │ ├── testfilebazminppc64.bz2
│ │ ├── testfilebazminppc64_pl.bz2
│ │ ├── testfilebazminppc64_plr.bz2
│ │ ├── testfilebaztab.bz2
│ │ ├── testfilebaztabppc64.bz2
│ │ ├── testfiledwarfinlines.bz2
│ │ ├── testfiledwarfinlines.core.bz2
│ │ ├── testfilefoobarbaz.bz2
│ │ ├── testfilegdbindex5.bz2
│ │ ├── testfilegdbindex7.bz2
│ │ ├── testfileloc.bz2
│ │ ├── testfilemacro.bz2
│ │ ├── testfilenolines.bz2
│ │ ├── testfileppc32-debugframe.bz2
│ │ ├── testfileppc32.bz2
│ │ ├── testfileppc32attrs.o.bz2
│ │ ├── testfileppc64-debugframe.bz2
│ │ ├── testfileppc64.bz2
│ │ ├── testfileppc64attrs.o.bz2
│ │ ├── testfileranges4.debug.bz2
│ │ ├── testfileranges5.debug.bz2
│ │ ├── testfiles390.bz2
│ │ ├── testfiles390x.bz2
│ │ ├── testfilesparc64attrs.o.bz2
│ │ ├── testfilesplitranges4.debug.bz2
│ │ ├── testfilesplitranges5.debug.bz2
│ │ ├── testlib_dynseg.so.bz2
│ │ ├── typeiter.c
│ │ ├── typeiter2.c
│ │ ├── unit-info.c
│ │ ├── update1.c
│ │ ├── update2.c
│ │ ├── update3.c
│ │ ├── update4.c
│ │ ├── varlocs.c
│ │ ├── vdsosyms.c
│ │ ├── vendorelf.c
│ │ └── zstrptr.c
│ └── version.h
├── tracers-libstapsdt-sys/
│ ├── Cargo.toml
│ ├── LICENSE
│ ├── bindgen.sh
│ ├── build.rs
│ └── src/
│ ├── lib.h
│ ├── lib.rs
│ ├── libstapsdt.rs
│ └── test-libstapsdt.c
├── tracers-macros/
│ ├── Cargo.toml
│ └── src/
│ └── lib.rs
└── tracers-macros-hack/
├── Cargo.toml
└── src/
└── lib.rs
================================================
FILE CONTENTS
================================================
================================================
FILE: .cirrus.yml
================================================
freebsd_instance:
image: freebsd-12-0-release-amd64
task:
name: FreeBSD 12.0 amd64
setup_script:
- pkg install -y curl
- curl https://sh.rustup.rs -sSf --output rustup.sh
- sh rustup.sh -y
cargo_cache:
folder: $HOME/.cargo/registry
build_script:
- . $HOME/.cargo/env
- cargo build --manifest-path tracers/Cargo.toml
- cargo build --manifest-path tracers/Cargo.toml --no-default-features
test_script:
- . $HOME/.cargo/env
- TRACERS_EXPECTED_DYNAMIC_IMPL=DISABLED TRACERS_EXPECTED_PROVIDER=tracers_test_probes::static/static_noop::0.1.0 cargo test --manifest-path tracers/Cargo.toml
- TRACERS_EXPECTED_DYNAMIC_IMPL=DISABLED TRACERS_EXPECTED_PROVIDER=tracers_test_probes::disabled::0.1.0 cargo test --manifest-path tracers/Cargo.toml --no-default-features
bench_script:
- . $HOME/.cargo/env
- cargo bench --manifest-path tracers/Cargo.toml
- cargo bench --manifest-path tracers/Cargo.toml --no-default-features
before_cache_script:
- rm -rf $HOME/.cargo/registry/index
================================================
FILE: .gitignore
================================================
# Generated by Cargo
# will have compiled files and executables
target/
# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
Cargo.lock
# These are backup files generated by rustfmt
**/*.rs.bk
/target
**/*.rs.bk
Cargo.lock
================================================
FILE: .gitmodules
================================================
[submodule "libstapsdt-sys/vendor/libstapsdt"]
path = tracers-libstapsdt-sys/vendor/libstapsdt
url = https://github.com/sthima/libstapsdt.git
[submodule "libelf-sys/vendor/libelf"]
path = libelf-sys/vendor/libelf
url = git://sourceware.org/git/elfutils.git
================================================
FILE: .tmuxp.yaml
================================================
session_name: tracers
start_directory: ./
windows:
- window_name: editor
focus: true
panes:
- vim
- window_name: rust shell
panes:
- shell_command: cargo watch
- window_name: misc shell
panes:
- pane
================================================
FILE: Cargo.toml
================================================
[workspace]
members = [
"tracers-libelf-sys",
"tracers-libstapsdt-sys",
"tracers-build",
"tracers-codegen",
"tracers-core",
"tracers-macros",
"tracers-macros-hack",
"tracers-dyn-noop",
"tracers-dyn-stap",
"tracers",
"examples/simple"
]
[profile.bench]
debug = true
#lto = true
[profile.test]
debug = true
[profile.release]
debug = true
#lto = true
================================================
FILE: LICENSE
================================================
This project is licensed under either of
* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
http://www.apache.org/licenses/LICENSE-2.0)
* MIT license ([LICENSE-MIT](LICENSE-MIT) or
http://opensource.org/licenses/MIT)
at your option.
================================================
FILE: LICENSE-APACHE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2019 Adam Nelson
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: LICENSE-MIT
================================================
Copyright (c) 2019 Adam Nelson
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
================================================
FILE: README.md
================================================
# tracers - Rust instrumentation library
[](https://crates.io/crates/tracers)
[](https://dev.azure.com/anelson-open-source/tracers/_build/latest?definitionId=4&branchName=master)
[](https://cirrus-ci.com/github/anelson/tracers)
# Summary
`tracers` is intended to be an easy to use and cross-platform Rust crate which makes it easy to add high-performance
low-overhead probes to Rust programs. Underneath it will use each platform's native probing mechanism, like System Tap
on Linux, DTrace on BSD, and ETW on Windows. Those platforms without a supported probing mechanism will fall back to
a no-op implementation.
A key goal of this crate is to be able to drop it in to any Rust project, create and fire probes wherever it makes
sense, and leave those probes in place all the time. When probes are disabled at compile time, there should be zero
runtime impact, and when probes are compiled in but not enabled at runtime the probe impact should be no more than one
or two CPU instructions.
# Status
*IMPORTANT*: `tracers` is still experimental. The author is using it internally but this crate is still not yet widely
used and may contain subtle and critical defects.
# Quick start
In your `Cargo.toml` you need to add:
[dependencies]
...
tracers = "0.1.0"
tracers-macros = "0.1.0"
[build-dependencies]
...
tracers-build = "0.1.0"
It's important not to forget to add `tracers-build` to your `build-dependencies`, because you'll need that available at
build time for the next step, which is to create a `src/build.rs` file if you don't have one already, and make sure it
contains this:
use tracers_build::build;
fn main() {
build();
}
If you have an existing `build.rs` you'll need to make sure you add a call to `tracers_build::build()` somewhere in the
`main` function, preferably early.
At this point you have all you need to define a tracer. Here's a simple example:
use tracers_macros::{probe, tracer};
#[tracer]
trait SimpleProbes {
fn hello(who: &str);
fn greeting(greeting: &str, name: &str);
fn optional_greeting(greeting: &str, name: &Option<&str>);
}
fn main() {
loop {
probe!(SimpleProbes::hello("world"));
probe!(SimpleProbes::greeting("hello", "world"));
let name = Some("world");
probe!(SimpleProbes::optional_greeting("hello", &name));
let name: Option<&str> = None;
probe!(SimpleProbes::optional_greeting("hello", &name));
}
}
You have have defined three probes, `hello`, `greeting`, and `optional_greeting`. By default, tracing is disabled at
compile time, so when you run this code all of the probing infrastructure will be optimized away and you'll be left with
zero runtime overhead.
To actually enable probing you need to activate one of the corresponding features in the `tracers` crate. For example,
in your `Cargo.toml`:
[dependencies]
...
tracers = { version = "0.1.0", features = [ "force_static_stap"]
will enable SystemTap tracing. If you rebuild again and use a tool like `tplist` from
[BCC](https://github.com/iovisor/bcc) you should be able to see the probes in the binary.
Note also that the `#[tracers]` macro generates some useful documentation on your trait. Try `cargo doc` and find your
trait in the docs for additional hints on how to use each probe.
The `examples/` directory has some simple examples.
# Platforms
The `tracers` crate and runtime components should compile and run on any supported Rust platform (although `no_std` is
not yet supported). Adding `tracers` as a dependency shouldn't break your project on any platform; if it does that's
a bug and you're encouraged to open a GitHub issue.
That said, the `tracers` crate by default doesn't actually trace anything; it compiles away to nothing. To actually
enable tracing you need a supported platform. As of this writing that means:
* Linux with System Tap (the `force_static_stap` feature)
* Linux with LTT-ng (the `force_static_lttng`) feature
There is work being done to support:
* Windows (with the Event Tracing for Windows system API)
* FreeBSD and macOS (with DTrace)
# License
Except where otherwise indicated, this project is licensed under either of
* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
* MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
at your option.
However, the following `-sys` crates have the license
corresponding to the third-party code which they wrap:
* [`tracers-libelf-sys`](tracers-libelf-sys/) - Wraps `elfutils` libraries and thus is licensed LGPLv3
* [`tracers-libstapsdt-sys`](tracers-libstapsdt-sys/) - Wraps `libstapsdt` and thus is licensed MIT
### Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in `tracers` by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.
# Releasing
This section applies to maintainers only.
To release a new version, dependent crates must be released first. The `bin/publish.sh` script helps to automate the
process but it's still quite manual.
Release process:
1. Update the `version` property of all crates and of all crates' dependencies on other `tracers` crates to the new
target version.
1. Ensure all dependencies have both a path dependency for local development, and a version dependency for publishing.
These must be consistent with the new version being published.
1. Update the `documentation` link to reflect the current version.
1.
Crates must be published in this order:
* `tracers-core`
* `tracers-libelf-sys`
* `tracers-libstapsdt-sys`
* `tracers-codegen`
* `tracers-macros-hack`
* `tracers-macros`
* `tracers-dyn-stap`
* `tracers-dyn-noop`
* `tracers-build`
* `tracers`
================================================
FILE: azure-pipelines.yml
================================================
# This pipeline stolen shamelessly from https://github.com/nickbabcock/rrinlog
trigger:
branches:
include: ['*']
tags:
include: ['*']
jobs:
- job: 'Rustfmt'
pool:
vmImage: 'ubuntu-16.04'
container: 'rust:latest'
condition: eq(variables['Build.Reason'], 'PullRequest')
steps:
- script: rustup component add rustfmt
displayName: Install Rustfmt
- script: cargo fmt --all -- --check
displayName: Run fmt
- job: 'Test'
strategy:
matrix:
windows-stable:
imageName: 'vs2017-win2016'
rustup_toolchain: stable
mac-stable:
imageName: 'macos-10.13'
rustup_toolchain: stable
linux-stable:
imageName: 'ubuntu-16.04'
rustup_toolchain: stable
linux-beta:
imageName: 'ubuntu-16.04'
rustup_toolchain: beta
linux-nightly:
imageName: 'ubuntu-16.04'
rustup_toolchain: nightly
pool:
vmImage: $(imageName)
steps:
- script: |
curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain $RUSTUP_TOOLCHAIN
echo "##vso[task.setvariable variable=PATH;]$PATH:$HOME/.cargo/bin"
displayName: Install rust (non-Windows)
condition: ne( variables['Agent.OS'], 'Windows_NT' )
- script: |
curl -sSf -o rustup-init.exe https://win.rustup.rs
rustup-init.exe -y --default-toolchain %RUSTUP_TOOLCHAIN%
echo "##vso[task.setvariable variable=PATH;]%PATH%;%USERPROFILE%\.cargo\bin"
displayName: Install rust (Windows)
condition: eq( variables['Agent.OS'], 'Windows_NT' )
- script: |
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 4052245BD4284CDD
echo "deb https://repo.iovisor.org/apt/$(lsb_release -cs) $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/iovisor.list
sudo apt-add-repository ppa:lttng/stable-2.10
sudo apt-get update
sudo apt-get install build-essential m4
sudo apt-get install bcc-tools libbcc-examples linux-headers-$(uname -r)
sudo apt-get install lttng-tools lttng-modules-dkms liblttng-ust-dev
echo "##vso[task.setvariable variable=PATH;]$PATH:/usr/share/bcc/tools"
displayName: install Ubuntu dependencies
condition: eq( variables['Agent.OS'], 'Linux' )
- script: scripts/build.sh --release --all --features binaries
displayName: Cargo build (non-Windows)
condition: ne( variables['Agent.OS'], 'Windows_NT' )
continueOnError: ${{ ne( variables['rustup_toolchain'], 'stable') }}
- script: scripts\build.bat --release --all --features binaries
displayName: Cargo build (Windows)
condition: eq( variables['Agent.OS'], 'Windows_NT' )
continueOnError: ${{ ne( variables['rustup_toolchain'], 'stable') }}
- script: |
TRACERS_EXPECTED_DYNAMIC_IMPL=dyn_stap \
TRACERS_EXPECTED_PROVIDER=tracers_test_probes::dynamic/dyn_stap::0.2.0 \
scripts/test.sh --manifest-path tracers/Cargo.toml --no-default-features --features=dynamic-tracing
cargo bench --manifest-path tracers/Cargo.toml --no-default-features --features=dynamic-tracing --no-run
sudo -E `which cargo` bench --manifest-path tracers/Cargo.toml --no-default-features --features=dynamic-tracing
displayName: Cargo test dynamic SystemTap implementation (Linux)
condition: eq( variables['Agent.OS'], 'Linux' )
continueOnError: ${{ ne( variables['rustup_toolchain'], 'stable') }}
- script: |
TRACERS_EXPECTED_DYNAMIC_IMPL=DISABLED \
TRACERS_EXPECTED_PROVIDER=tracers_test_probes::static/static_noop::0.2.0 \
scripts/test.sh --manifest-path tracers/Cargo.toml
cargo bench --manifest-path tracers/Cargo.toml
displayName: Cargo test default Static NoOp implementation (non-Windows)
condition: ne( variables['Agent.OS'], 'Windows_NT' )
continueOnError: ${{ ne( variables['rustup_toolchain'], 'stable') }}
- script: |
TRACERS_EXPECTED_DYNAMIC_IMPL=DISABLED \
TRACERS_EXPECTED_PROVIDER=tracers_test_probes::static/static_stap::0.2.0 \
scripts/test.sh --manifest-path tracers/Cargo.toml --features=force-static-stap
cargo bench --manifest-path tracers/Cargo.toml --features=force-static-stap --no-run
# Must run as root in order to enable probes
sudo -E `which cargo` bench --manifest-path tracers/Cargo.toml --features=force-static-stap
displayName: Cargo test Static Stap implementation (Linux)
condition: eq( variables['Agent.OS'], 'Linux' )
continueOnError: ${{ ne( variables['rustup_toolchain'], 'stable') }}
- script: |
TRACERS_EXPECTED_DYNAMIC_IMPL=DISABLED \
TRACERS_EXPECTED_PROVIDER=tracers_test_probes::static/static_lttng::0.2.0 \
scripts/test.sh --manifest-path tracers/Cargo.toml --features=force-static-lttng
cargo bench --manifest-path tracers/Cargo.toml --features=force-static-lttng
displayName: Cargo test Static LTTng implementation (Linux)
condition: eq( variables['Agent.OS'], 'Linux' )
continueOnError: ${{ ne( variables['rustup_toolchain'], 'stable') }}
- script: |
TRACERS_EXPECTED_DYNAMIC_IMPL=DISABLED \
TRACERS_EXPECTED_PROVIDER=tracers_test_probes::disabled::0.2.0 \
scripts/test.sh --manifest-path tracers/Cargo.toml --no-default-features
cargo bench --manifest-path tracers/Cargo.toml --no-default-features
displayName: Cargo test tracing disabled (non-Windows)
condition: ne( variables['Agent.OS'], 'Windows_NT' )
continueOnError: ${{ ne( variables['rustup_toolchain'], 'stable') }}
- script: |
echo ##vso[task.setvariable variable=TRACERS_EXPECTED_DYNAMIC_IMPL;]DISABLED
echo ##vso[task.setvariable variable=TRACERS_EXPECTED_PROVIDER;]tracers_test_probes::static/static_noop::0.2.0
displayName: Set env vars to test default Static NoOp implementation (Windows)
condition: eq( variables['Agent.OS'], 'Windows_NT' )
continueOnError: ${{ ne( variables['rustup_toolchain'], 'stable') }}
- script: |
scripts\test.bat --manifest-path tracers/Cargo.toml
cargo bench --manifest-path tracers/Cargo.toml
displayName: Cargo test default Static NoOp implementation (Windows)
condition: eq( variables['Agent.OS'], 'Windows_NT' )
continueOnError: ${{ ne( variables['rustup_toolchain'], 'stable') }}
- script: |
echo ##vso[task.setvariable variable=TRACERS_EXPECTED_DYNAMIC_IMPL;]DISABLED
echo ##vso[task.setvariable variable=TRACERS_EXPECTED_PROVIDER;]tracers_test_probes::disabled::0.2.0
displayName: Set env vars to test tracing disabled (Windows)
condition: eq( variables['Agent.OS'], 'Windows_NT' )
continueOnError: ${{ ne( variables['rustup_toolchain'], 'stable') }}
- script: |
scripts\test.bat --manifest-path tracers/Cargo.toml --no-default-features
cargo bench --manifest-path tracers/Cargo.toml --no-default-features
displayName: Cargo test tracing disabled (Windows)
condition: eq( variables['Agent.OS'], 'Windows_NT' )
continueOnError: ${{ ne( variables['rustup_toolchain'], 'stable') }}
# Run clippy, but with some caveats:
# * Can't use `--all-features` because they're mutually exclusive; use default and `force-static-stap`
# * There's a bug in the identity_conversion that makes it fail without printing a line number, so I don't know
# where the problem is. For now disable that lint
- script: |
rustup component add clippy && cargo clippy --all-targets -- -D warnings -a clippy::identity-conversion
rustup component add clippy && cargo clippy --all-targets --features force-static-stap -- -D warnings -a clippy::identity-conversion
displayName: Run Clippy linter on Rust code (only on Rust stable)
condition: and(eq( variables['Agent.OS'], 'Linux' ), eq( variables['rustup_toolchain'], 'stable' ))
================================================
FILE: bin/pre-publish.sh
================================================
#!/usr/bin/env bash
#
# Does a dry run on publishing all crates to check for problems
set -e
SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
CRATES=( \
tracers-core \
tracers-libelf-sys \
tracers-libstapsdt-sys \
tracers-codegen \
tracers-build \
tracers-macros-hack \
tracers-macros \
tracers-dyn-noop \
tracers-dyn-stap \
tracers \
)
echo "Running cargo publish --dry-run on all crates"
for crate in "${CRATES[@]}"
do
echo "Pre-publishing crate $crate"
cargo publish --dry-run --manifest-path "$SCRIPTPATH/../$crate/Cargo.toml"
done
================================================
FILE: bin/publish.sh
================================================
#!/usr/bin/env bash
#
# Borrowed quite shamelessly from https://github.com/tracers-rs/tracing/blob/master/bin/publish
set -e
USAGE="Publish a new release of a tracers crate
USAGE:
$(basename "$0") [OPTIONS] [CRATE] [VERSION]
OPTIONS:
-v, --verbose Use verbose Cargo output
-d, --dry-run Perform a dry run (do not publish or tag the release)
-h, --help Show this help text and exit"
DRY_RUN=""
VERBOSE=""
err() {
echo -e "\e[31m\e[1merror:\e[0m $@" 1>&2;
}
status() {
WIDTH=12
printf "\e[32m\e[1m%${WIDTH}s\e[0m %s\n" "$1" "$2"
}
verify() {
status "Verifying" "if $CRATE v$VERSION can be released"
ACTUAL=$(cargo pkgid | sed -n 's/.*#\(.*\)/\1/p')
if [ "$ACTUAL" != "$VERSION" ]; then
err "expected to release version $VERSION, but Cargo.toml contained $ACTUAL"
exit 1
fi
if git tag -l | grep -Fxq "$TAG" ; then
err "git tag \`$TAG\` already exists"
exit 1
fi
# As of recent versions of Cargo this isn't true; path dependencies can be left in as long as there is also an
# explicit version dependency also.
#PATH_DEPS=$(grep -F "path = \"" Cargo.toml | sed -e 's/^/ /')
#if [ -n "$PATH_DEPS" ]; then
# err "crate \`$CRATE\` contained path dependencies:\n$PATH_DEPS"
# echo "path dependencies must be removed prior to release"
# exit 1
#fi
}
release() {
status "Releasing" "$CRATE v$VERSION"
cargo package $VERBOSE
cargo publish $VERBOSE $DRY_RUN
status "Tagging" "$TAG"
# NB: Do not push the tags here, because my SSH config requires manual interaction with the yubikey to auth
# to github which breaks this flow
if [ -n "$DRY_RUN" ]; then
echo "# git tag $TAG"
else
git tag "$TAG"
fi
}
while [[ $# -gt 0 ]]
do
case "$1" in
-v|--verbose)
VERBOSE="--verbose"
set +x
shift
;;
-d|--dry-run)
DRY_RUN="--dry-run"
shift
;;
-*)
err "unknown flag \"$1\""
echo "$USAGE"
exit 1
;;
*) # crate or version
if [ -z "$CRATE" ]; then
CRATE="$1"
elif [ -z "$VERSION" ]; then
VERSION="$1"
else
err "unknown positional argument \"$1\""
echo "$USAGE"
exit 1
fi
shift
;;
esac
done
# set -- "${POSITIONAL[@]}"
if [ -z "$VERSION" ]; then
err "no version specified!"
HELP=1
fi
if [ -n "$CRATE" ]; then
TAG="$CRATE-$VERSION"
else
err "no crate specified!"
HELP=1
fi
if [ -n "$HELP" ]; then
echo "$USAGE"
exit 1
fi
if [ -d "$CRATE" ]; then
(cd "$CRATE" && verify && release )
else
err "no such crate \"$CRATE\""
exit 1
fi
================================================
FILE: examples/simple/Cargo.toml
================================================
[package]
name = "simple"
version = "0.2.0"
authors = ["Adam Nelson <anelson@users.noreply.github.com>"]
edition = "2018"
[dependencies]
tracers = { path = "../../tracers", version = "0.2.0" }
tracers-macros = { path = "../../tracers-macros", version = "0.2.0" }
[build-dependencies]
tracers-build = { path = "../../tracers-build", version = "0.2.0" }
================================================
FILE: examples/simple/build.rs
================================================
use tracers_build::build;
fn main() {
build();
}
================================================
FILE: examples/simple/src/main.rs
================================================
//! This is a simple binary which declares and fires some simple probes
//!
//! It's the "hello world" equivalent for tracing
#![deny(warnings)]
use tracers_macros::{probe, tracer};
#[tracer]
trait SimpleProbes {
fn hello(who: &str);
fn greeting(greeting: &str, name: &str);
fn optional_greeting(greeting: &str, name: &Option<&str>);
}
fn main() {
loop {
probe!(SimpleProbes::hello("world"));
probe!(SimpleProbes::greeting("hello", "world"));
let name = Some("world");
probe!(SimpleProbes::optional_greeting("hello", &name));
let name: Option<&str> = None;
probe!(SimpleProbes::optional_greeting("hello", &name));
}
}
================================================
FILE: scripts/build.bat
================================================
@ ECHO OFF
cargo build %*
================================================
FILE: scripts/build.sh
================================================
#!/usr/bin/env bash
#
# Builds the project on UNIX-like systems
set -u
set -e
cargo build \
"$@"
================================================
FILE: scripts/test.bat
================================================
@ ECHO OFF
cargo test %*
================================================
FILE: scripts/test.sh
================================================
#!/usr/bin/env bash
#
# Builds the project on UNIX-like systems
set -u
set -e
cargo test \
"$@"
================================================
FILE: tracers/Cargo.toml
================================================
[package]
name = "tracers"
version = "0.2.0"
authors = ["Adam Nelson <anelson@127.io>"]
edition = "2018"
license = "MIT OR Apache-2.0"
autobenches = false
description = "Generates very low overhead native trace points using stable Rust"
repository = "https://github.com/anelson/tracers"
readme = "../README.md"
keywords = ["tracers", "systemtap", "ltt-ng", "ebpf", "tracing"]
categories = ["os", "development-tools::profiling"]
# This is a hack. Or maybe a workaround for a bug.
#
# It seems that Cargo does not pass variables to dependent crates using the DEP_(PKGNAME)_(VARNAME)
# env vars unless it thinks the crate is wrapping a native library. This package is definitely not
# doing that, but setting this in the manifest ensures that the downstream dependencies' build.rs
# can query the variables produced by this `build.rs` to detect which prob impl was used at compile time
#
# This will be unnecessary once https://github.com/rust-lang/cargo/issues/3544 is implemented
links = "tracers"
[badges]
maintenance = { status = "experimental" }
cirrus-ci = { repository = "anelson/tracers", branch = "master" }
azure-devops = { project = "anelson-open-source/tracers", pipeline = "anelson.tracers", build="4" }
[features]
# By default, tracing is enabled and set to an automatically selected static implementation
default = ["tracing"]
tracing = ["static-tracing"]
# To enable dynamic tracing requires it be explicitly activated. Note this is mutually exclusive with
# enable-static-tracing
dynamic-tracing = ["once_cell", "tracers-core/dynamic", "tracers-dyn-stap/enabled", "tracers-dyn-noop"]
# Static tracing is built in to the generators, it doesn't have any additional dependent crates
static-tracing = ["tracers-core/default"]
force-dyn-stap = ["dynamic-tracing", "tracers-dyn-stap/required"]
force-dyn-noop = ["dynamic-tracing", "tracers-dyn-noop"]
force-static-noop = ["static-tracing"]
force-static-stap = ["static-tracing"]
force-static-lttng = ["static-tracing"]
# An optional feature will build binaries which are used to interact with the probing framework. These are only useful
# as part of our CI tests, or when troubleshooting unexpected behavior with the probes. If you are using this crate as a dependency,
# you should not activate this feature as it will add `tracers-macros` to the runtime-dependencies of `tracers`
binaries = ["nom", "tracers-macros"]
[[bin]]
name = "testfire"
path = "src/bin/testfire.rs"
required-features = [ "binaries" ]
[[bin]]
name = "profile_target"
path = "src/bin/profile_target.rs"
required-features = [ "binaries" ]
[[bench]]
name = "probe_firing"
harness = false
[dependencies]
once_cell = { version = "1.2.0", optional = true }
tracers-core = { path = "../tracers-core", version = "0.2.0", optional = true }
tracers-dyn-noop = { path = "../tracers-dyn-noop", version = "0.2.0", optional = true }
tracers-dyn-stap = { path = "../tracers-dyn-stap", version = "0.2.0", optional = true }
nom = { version = "5.0.1", optional = true }
tracers-macros = { path = "../tracers-macros", version = "0.2.0", optional = true }
[build-dependencies]
tracers-build = { path = "../tracers-build", version = "0.2.0" }
failure = "0.1.6"
[dev-dependencies]
# Our integration tests and examples assume the tracers-macros are available
tracers-macros = { path = "../tracers-macros", version = "0.2.0" }
criterion = "0.3.0"
failure = "0.1.6"
nix = "0.15.0"
================================================
FILE: tracers/benches/probe_firing.rs
================================================
#![deny(warnings)]
use criterion::{black_box, criterion_group, criterion_main, Bencher, Criterion, Fun};
#[allow(unused_imports)] //Depending on the build config this might be unused
use failure::bail;
use failure::Fallible;
#[allow(unused_imports)] //Depending on the build config this might be unused
use std::process::Child;
use tracers_macros::{init_provider, probe, tracer};
static INT_ARG: usize = 324;
static STRING_ARG: &str =
"fear is the mind killer I will face my fear I will let it pass through me";
#[tracer]
trait ProbeBenchmarks {
fn no_args();
fn int_arg1(arg0: usize);
fn int_arg3(arg0: usize, arg1: usize, arg2: usize);
fn int_arg6(arg0: usize, arg1: usize, arg2: usize, arg3: usize, arg4: usize, arg5: usize);
fn int_arg12(
arg0: usize,
arg1: usize,
arg2: usize,
arg3: usize,
arg4: usize,
arg5: usize,
arg6: usize,
arg7: usize,
arg8: usize,
arg9: usize,
arg10: usize,
arg11: usize,
);
fn string_arg1(arg0: &str);
fn string_arg3(arg0: &str, arg1: &str, arg2: &str);
fn string_arg6(arg0: &str, arg1: &str, arg2: &str, arg3: &str, arg4: &str, arg5: &str);
fn string_arg12(
arg0: &str,
arg1: &str,
arg2: &str,
arg3: &str,
arg4: &str,
arg5: &str,
arg6: &str,
arg7: &str,
arg8: &str,
arg9: &str,
arg10: &str,
arg11: &str,
);
}
fn bench_no_args(b: &mut Bencher, _arg: &()) {
b.iter(|| probe!(ProbeBenchmarks::no_args()))
}
fn bench_int_arg1(b: &mut Bencher, _arg: &()) {
b.iter(|| probe!(ProbeBenchmarks::int_arg1(black_box(INT_ARG))))
}
fn bench_int_arg3(b: &mut Bencher, _arg: &()) {
b.iter(|| {
probe!(ProbeBenchmarks::int_arg3(
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG)
))
})
}
fn bench_int_arg6(b: &mut Bencher, _arg: &()) {
b.iter(|| {
probe!(ProbeBenchmarks::int_arg6(
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG)
))
})
}
fn bench_int_arg12(b: &mut Bencher, _arg: &()) {
b.iter(|| {
probe!(ProbeBenchmarks::int_arg12(
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG),
black_box(INT_ARG)
))
})
}
fn bench_string_arg1(b: &mut Bencher, _arg: &()) {
b.iter(|| probe!(ProbeBenchmarks::string_arg1(black_box(STRING_ARG))))
}
fn bench_string_arg3(b: &mut Bencher, _arg: &()) {
b.iter(|| {
probe!(ProbeBenchmarks::string_arg3(
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG)
))
})
}
fn bench_string_arg6(b: &mut Bencher, _arg: &()) {
b.iter(|| {
probe!(ProbeBenchmarks::string_arg6(
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG)
))
})
}
fn bench_string_arg12(b: &mut Bencher, _arg: &()) {
b.iter(|| {
probe!(ProbeBenchmarks::string_arg12(
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG),
black_box(STRING_ARG)
))
})
}
fn bench_fire_disabled(c: &mut Criterion) {
bench_fire(c, false);
}
fn bench_fire_enabled(c: &mut Criterion) {
match enable_tracing() {
Err(e) => eprintln!("Unable to run benchmarks with probes enabled: {}", e),
Ok(trace) => {
bench_fire(c, true);
disable_tracing(trace);
}
}
}
/// Invokes an external command that will enable the tracing probes in this process.
#[cfg(all(target_os = "linux", any(static_stap_enabled, dynamic_stap_enabled)))]
fn enable_tracing() -> Fallible<Child> {
use failure::{format_err, ResultExt};
use std::env;
use std::io::ErrorKind;
use std::path::{Path, PathBuf};
use std::process::{self, Command};
fn is_root() -> bool {
env::var("USER")
.map(|user| user == "root")
.unwrap_or_default()
}
fn find_executable<P>(exe_name: P) -> Option<PathBuf>
where
P: AsRef<Path>,
{
env::var_os("PATH").and_then(|paths| {
env::split_paths(&paths)
.filter_map(|dir| {
let full_path = dir.join(&exe_name);
if full_path.is_file() {
Some(full_path)
} else {
None
}
})
.next()
})
}
//This should be done with `bpftrace`, however as of this writing (2019-05-10) this bug:
//https://github.com/iovisor/bpftrace/issues/612 prevents USDT probes using semaphore from
//functioning properly. Thankfully the older `funccount` utility in the `bcc` toolkit does
//work.
//
//Less fortunately, it is not compatible with Python3, so it needs to be invoked explicitly
//with the python2 interpreter, which we blithely assume is installed on the system
if !is_root() {
bail!("Benchmarking with probes enabled requires running as root");
}
let provider_info = init_provider!(ProbeBenchmarks).expect("Provider init failed");
if !provider_info.contains("static_stap") && !provider_info.contains("dyn_stap") {
bail!("Don't know how to enable {}", provider_info);
}
//Find where in the path the `funccount` utility is
let funccount_path = find_executable("funccount").ok_or_else(|| {
format_err!("Unable to locate `funccount` in the path; are the BCC tools installed?")
})?;
//Invoke `python2` with this funccount path and the args
//
//funccount's args will be:
// --pid $PID - The PID of this bencher process
// 'u:$EXE:*' - Filter expression, `$EXE` is the fully qualified path to this executable,
// `*` means all probes in the process
let exe_path = env::current_exe().context("current_exe failed")?;
let trace = match Command::new("python2")
.arg(funccount_path)
.args(&["--pid", &format!("{}", process::id())])
.arg(&format!("u:{}:*", exe_path.display()))
.spawn()
{
Err(ref e) if e.kind() == ErrorKind::NotFound => Err(format_err!(
"The `python2` executable wasn't found; make sure it's installed and in the path"
)),
Err(e) => Err(e.into()),
Ok(child) => Ok(child),
}?;
Ok(trace)
}
/// Disables tracing previously enabled by invoking `funccount`. When this function returns the
/// `funccount` process will have been terminated
#[cfg(all(target_os = "linux", any(static_stap_enabled, dynamic_stap_enabled)))]
fn disable_tracing(mut child: Child) {
use nix::sys::signal::{self, Signal};
use nix::unistd::Pid;
//Send SIGTERM to the child process, and collect it's stdoutput waiting for it to die
//That way we can see the function counts it prints and visually confirm the probes fired as
//expected
let pid = Pid::from_raw(child.id() as i32);
signal::kill(pid, Signal::SIGINT).expect("Failed to send SIGINT to child process");
child
.wait()
.expect("waiting for child process to terminate");
}
/// Invokes an external command that will enable the tracing probes in this process.
#[cfg(all(target_os = "linux", static_lttng_enabled))]
fn enable_tracing() -> Fallible<()> {
//The lttng command line tool doesn't require superuser privs so it's much easier than the
//dtract or systemtap versions
lttng(&["create"])?;
lttng(&["enable-event", "--userspace", "tracers_probe_benchmarks:*"])?;
lttng(&["start"])?;
Ok(())
}
/// Invokes the lttng CLI with specified args, as the current user
#[cfg(all(target_os = "linux", static_lttng_enabled))]
fn lttng(args: &[&str]) -> Fallible<()> {
use failure::format_err;
use std::io::ErrorKind;
use std::process::{Command, Stdio};
print!("lttng ");
for arg in args.iter() {
print!(" {}", arg);
}
println!();
match Command::new("lttng")
.args(args)
.stdout(Stdio::inherit())
.stderr(Stdio::inherit())
.output()
{
Err(ref e) if e.kind() == ErrorKind::NotFound => Err(format_err!(
"The `lttng` executable was not found; is the lttng-tools package installed?"
)),
Err(e) => Err(e.into()),
Ok(output) => {
if output.status.success() {
Ok(())
} else {
Err(format_err!(
"The lttng command failed with exit code {}",
output.status
))
}
}
}
}
/// Disables a previously enabled lttng tracing session
#[cfg(all(target_os = "linux", static_lttng_enabled))]
fn disable_tracing(_unused: ()) {
lttng(&["destroy"]).expect("failed to destroy LTTng session");
}
#[cfg(all(
target_os = "linux",
not(any(static_lttng_enabled, static_stap_enabled, dynamic_stap_enabled))
))]
fn enable_tracing() -> Fallible<()> {
bail!("No supported tracing implementations are enabled")
}
#[cfg(all(
target_os = "linux",
not(any(static_lttng_enabled, static_stap_enabled, dynamic_stap_enabled))
))]
fn disable_tracing(_unused: ()) {
unreachable!()
}
#[cfg(not(target_os = "linux"))]
fn enable_tracing() -> Fallible<()> {
bail!("Enabling probes on non-Linux targets is not yet supported")
}
#[cfg(not(target_os = "linux"))]
fn disable_tracing(_unused: ()) {
unreachable!()
}
fn bench_fire(c: &mut Criterion, enabled: bool) {
let funcs = vec![
Fun::new("no args", bench_no_args),
Fun::new("int_arg1", bench_int_arg1),
Fun::new("int_arg3", bench_int_arg3),
Fun::new("int_arg6", bench_int_arg6),
Fun::new("int_arg12", bench_int_arg12),
Fun::new("string_arg1", bench_string_arg1),
Fun::new("string_arg3", bench_string_arg3),
Fun::new("string_arg6", bench_string_arg6),
Fun::new("string_arg12", bench_string_arg12),
];
let provider_info = init_provider!(ProbeBenchmarks).expect("Provider init failed");
c.bench_functions(
&format!(
"{}abled '{}'",
if enabled { "en" } else { "dis" },
provider_info
),
funcs,
(),
);
}
criterion_group!(benches, bench_fire_disabled, bench_fire_enabled);
criterion_main!(benches);
================================================
FILE: tracers/build.rs
================================================
//! Custom build logic that uses the features enabled by the dependent crate to determine which
//! tracing implementation to compile with
fn main() {
tracers_build::tracers_build()
}
================================================
FILE: tracers/examples/simple.rs
================================================
#![deny(warnings)]
use tracers_macros::probe;
use tracers_macros::tracer;
#[tracer]
trait SimpleTestProbes {
fn probe0();
fn probe1(foo: &str);
}
fn main() {
println!("About to fire the probes...");
probe!(SimpleTestProbes::probe0());
probe!(SimpleTestProbes::probe1("foo bar baz"));
println!("The probes were fired");
}
================================================
FILE: tracers/examples/submodules.rs
================================================
//! it's also possible to declare a provider struct in one module and fire the probes from another.
//! the only requirement is that the visibility of the provider struct be such that the struct type
//! is accessible from the code that is firing the probe
#![deny(warnings)]
use tracers_macros::probe;
mod submodule_with_struct {
extern crate tracers;
use tracers_macros::tracer;
/// Note how this trait must be some kind of `pub`
#[tracer]
pub trait PublicTestProbes {
fn probe0();
fn probe1(foo: &str);
}
#[tracer]
pub(crate) trait CrateTestProbes {
fn probe0();
fn probe1(foo: &str);
}
#[tracer]
pub(super) trait SuperTestProbes {
fn probe0();
fn probe1(foo: &str);
}
}
use submodule_with_struct::*;
fn main() {
println!("About to fire the probes...");
probe!(PublicTestProbes::probe0());
probe!(PublicTestProbes::probe1("foo bar baz"));
probe!(CrateTestProbes::probe0());
probe!(CrateTestProbes::probe1("foo bar baz"));
probe!(SuperTestProbes::probe0());
probe!(SuperTestProbes::probe1("foo bar baz"));
println!("The probes were fired");
}
================================================
FILE: tracers/src/bin/profile_target.rs
================================================
//! This very simple binary is used for profiling the tracing system itself to experiment with
//! various optimizations and the effect they have on code generation.
//!
//! For actual benchmarking the code in the `benches/` directory is used instead
use std::ptr;
use tracers_macros::probe;
use tracers_macros::tracer;
#[tracer]
trait SimpleTestProbes {
fn probe_no_args();
fn probe_str_arg(arg0: &str);
fn probe_int_arg(arg0: usize);
fn probe_ptr_arg(arg0: *const u8);
}
static INT_ARG: usize = 52;
static STRING_ARG: &str = "foo bar baz";
fn main() {
loop {
unsafe {
//TODO: use read_volatile to avoid compiler optimizations
probe!(SimpleTestProbes::probe_no_args());
probe!(SimpleTestProbes::probe_str_arg(ptr::read_volatile(
&STRING_ARG
)));
probe!(SimpleTestProbes::probe_int_arg(ptr::read_volatile(
&INT_ARG
)));
let ptr_arg: *const u8 = *&INT_ARG as *const u8;
probe!(SimpleTestProbes::probe_ptr_arg(ptr::read_volatile(
&ptr_arg
)));
}
}
}
================================================
FILE: tracers/src/bin/stap_probes.d
================================================
provider staptest {
probe probe0();
}
================================================
FILE: tracers/src/bin/stap_probes.h
================================================
/* Generated by the Systemtap dtrace wrapper */
#define _SDT_HAS_SEMAPHORES 1
#define STAP_HAS_SEMAPHORES 1 /* deprecated */
#include <sys/sdt.h>
/* STAPTEST_PROBE0 ( ) */
#if defined STAP_SDT_V1
#define STAPTEST_PROBE0_ENABLED() __builtin_expect (probe0_semaphore, 0)
#define staptest_probe0_semaphore probe0_semaphore
#else
#define STAPTEST_PROBE0_ENABLED() __builtin_expect (staptest_probe0_semaphore, 0)
#endif
__extension__ extern unsigned short staptest_probe0_semaphore __attribute__ ((unused)) __attribute__ ((section (".probes")));
#define STAPTEST_PROBE0() \
DTRACE_PROBE (staptest, probe0)
================================================
FILE: tracers/src/bin/stap_probes.o.dtrace-temp.c
================================================
/* Generated by the Systemtap dtrace wrapper */
static void __dtrace (void) __attribute__((unused));
static void __dtrace (void) {}
#include <sys/sdt.h>
#if defined STAP_SDT_V1
#define staptest_probe0_semaphore probe0_semaphore
#endif
#if defined STAP_SDT_V1 || defined STAP_SDT_V2
__extension__ unsigned short staptest_probe0_semaphore __attribute__ ((unused)) __attribute__ ((section (".probes")));
#else
__extension__ unsigned short staptest_probe0_semaphore __attribute__ ((unused)) __attribute__ ((section (".probes"))) __attribute__ ((visibility ("hidden")));
#endif
================================================
FILE: tracers/src/bin/testfire.rs
================================================
use nom::*;
use std::io::prelude::*;
use tracers_macros::{init_provider, probe, tracer};
/// This is a probe provider which is used to exercise the probing infrastructure with a few
/// different combinations of arguments.
#[tracer]
pub trait TestFireProbes {
fn probe0();
fn probe1(text: &str);
fn probe2(text: &str, number: usize);
fn probe3(text: &str, number: usize, opt: &Option<&String>);
}
#[derive(Debug, PartialEq)]
enum ProbeType {
Probe0,
Probe1 {
text: String,
},
Probe2 {
text: String,
number: usize,
},
Probe3 {
text: String,
number: usize,
opt: Option<String>,
},
}
named!(
quoted_string<&str, String>,
map!(
delimited!(tag!("\""), take_until!("\""), tag!("\"")),
|s| String::from(s)
)
);
named!(number<&str, usize>, map_res!(take_while!(|c: char| c.is_ascii_digit()), |num: &str| num.parse::<usize>()));
named!(optional_string<&str, Option<String>>, opt!(complete!(quoted_string)));
named!(eol<&str, &str>, tag!(";"));
named!(
probe0<&str, ProbeType>,
do_parse!(tag!("probe0") >> eol >> (ProbeType::Probe0))
);
named!(
probe1<&str, ProbeType>,
do_parse!(
tag!("probe1") >>
sp >>
text: quoted_string >>
eol >> (
ProbeType::Probe1 { text }
)
)
);
named!(
probe2<&str, ProbeType>,
do_parse!(
tag!("probe2") >>
sp >>
text: quoted_string >>
sp >>
number: number >>
eol >> (
ProbeType::Probe2 { text, number }
)
)
);
named!(
probe3<&str, ProbeType>,
do_parse!(
tag!("probe3") >>
sp >>
text: quoted_string >>
sp >>
number: number >>
sp >>
opt: optional_string >>
eol >> (
ProbeType::Probe3 { text, number, opt }
)
)
);
named!(
probe_command<&str, ProbeType>,
complete! (
alt! (
probe0 | probe1 | probe2 | probe3
)
)
);
fn fire_probe(pt: ProbeType) {
match pt {
ProbeType::Probe0 => probe!(TestFireProbes::probe0()),
ProbeType::Probe1 { text } => probe!(TestFireProbes::probe1(&text)),
ProbeType::Probe2 { text, number } => probe!(TestFireProbes::probe2(&text, number)),
ProbeType::Probe3 { text, number, opt } => {
probe!(TestFireProbes::probe3(&text, number, &opt.as_ref()))
}
}
}
fn main() {
println!("Initializing the probe provider");
match init_provider!(TestFireProbes) {
Ok(ver) => println!("Provider initialized: {}", ver),
Err(err) => panic!("Probe provider initialization failed: {}", err),
}
println!("Probe provider initialized");
for line in std::io::stdin().lock().lines() {
let line = line.expect("Error reading line from stdin");
//Implement a primitive parser to parse commands. Each command is the name of a probe to
//fire and then its arguments.
match probe_command(&line) {
Ok((_, pt)) => fire_probe(pt),
Err(e) => panic!("Invalid input '{}': {}", line, e),
}
}
}
================================================
FILE: tracers/src/lib.rs
================================================
#![deny(warnings)]
/// The code generated by `tracers-macros` will at runtime require some functionality, both from
/// within this crate but also from third-party crates like `failure`. It's important that the
/// generated code use _our_ version of these crates, and not be required to add some explicit
/// dependency itself. So we'll re-export those dependencies here
/// Re-export our two dependencies that are actually used by code in user crates generated by
/// `tracers!` macro. By re-exporting the crate and not just the types, we ensure the correct
/// version will be used and spare the user having to add these dependencies themselves. A deeper
/// discussion around this is ongoing right now at:
/// https://github.com/rust-lang-nursery/api-guidelines/issues/176
///
/// The `build.rs` will set a feature to indicate if tracing is enabled at all. If not then
/// there's no reason to even include this runtime
#[cfg(enabled)]
pub mod runtime {
pub use tracers_core::failure;
pub use tracers_core::libc;
pub use tracers_core::{wrap, ProbeArgNativeType, ProbeArgType, ProbeArgWrapper};
#[cfg(dynamic_enabled)]
pub mod dynamic {
pub extern crate once_cell;
pub use tracers_core::dynamic::*;
// Re-export some types from child crates which callers will need to be able to use. Ergonomically
// it makes more sense to a caller to deal with, for example, `tracers::Provider`
//Alias `SystemTracer` to the appropriate implementation based on the determination made in
//`build.rs`
#[cfg(dyn_stap_enabled)]
pub type SystemTracer = tracers_dyn_stap::StapTracer;
#[cfg(dyn_noop_enabled)]
pub type SystemTracer = tracers_noop::NoOpTracer;
#[cfg(dynamic_enabled)]
pub type SystemProvider = <SystemTracer as Tracer>::ProviderType;
#[cfg(dynamic_enabled)]
pub type SystemProbe = <SystemTracer as Tracer>::ProbeType;
}
}
#[cfg(test)]
mod test {
#[cfg(dynamic_enabled)]
use super::runtime::*;
#[cfg(dynamic_enabled)]
use tracers_core::dynamic::Tracer;
#[test]
#[cfg(dynamic_enabled)]
fn verify_expected_dynamic_tracing_impl() {
//This very simple test checks the TRACERS_EXPECTED_DYNAMIC_IMPL env var, and if set, asserts that
//the tracing implementation compiled into this library matches the expected one. In
//practice this is only used by the CI builds to verify that the compile-time magic always
//ends up with the expeced implementation on a variety of environments
if let Ok(expected_impl) = std::env::var("TRACERS_EXPECTED_DYNAMIC_IMPL") {
assert_eq!(expected_impl, dynamic::SystemTracer::TRACING_IMPLEMENTATION);
}
}
#[test]
#[cfg(not(dynamic_enabled))]
fn verify_expected_dynamic_tracing_impl() {
//This very simple test checks the TRACERS_EXPECTED_DYNAMIC_IMPL env var, and if set, asserts that
//the tracing implementation compiled into this library matches the expected one. In
//practice this is only used by the CI builds to verify that the compile-time magic always
//ends up with the expeced implementation on a variety of environments
if let Ok(expected_impl) = std::env::var("TRACERS_EXPECTED_DYNAMIC_IMPL") {
assert_eq!(expected_impl, "DISABLED",
"the crate was compiled with dynamic tracing disabled but apparently the expected implementation was '{}'", expected_impl);
}
}
}
================================================
FILE: tracers/tests/custom_provider_names.rs
================================================
//! The default provider name is derived from the trait's name. But this name is used to make the
//! names of the native code elements like semaphores. So if two traits have the same provider
//! name it will result in linker errors. If this compiles and runs it means the customer provider
//! name is being applied to the native code elements also
#![deny(warnings)]
#![allow(clippy::blacklisted_name)] //"foo"
use tracers_macros::probe;
mod foo {
use tracers_macros::tracer;
#[tracer(provider_name = "test_probes_1")]
pub trait TestProbes {
fn probe0();
fn probe1(foo: &str);
}
}
mod bar {
use tracers_macros::tracer;
#[tracer(provider_name = "test_probes_2")]
pub trait TestProbes {
fn probe1(foo: &str);
fn probe2(foo: &str, bar: usize);
}
}
#[test]
fn probe_firing() {
probe!(foo::TestProbes::probe0());
probe!(foo::TestProbes::probe1("foo bar baz"));
probe!(bar::TestProbes::probe1("foo bar baz"));
probe!(bar::TestProbes::probe2("foo bar baz", 5));
}
================================================
FILE: tracers/tests/simple.rs
================================================
#![deny(warnings)]
#![allow(clippy::blacklisted_name)] //"foo"
use tracers_macros::{init_provider, probe, tracer};
#[tracer]
trait TestProbes {
fn probe0();
fn probe1(foo: &str);
fn probe2(foo: &str, bar: usize);
}
#[test]
fn probe_firing() {
probe!(TestProbes::probe0());
probe!(TestProbes::probe1("foo bar baz"));
probe!(TestProbes::probe2("foo bar baz", 5));
}
#[test]
fn expected_impl() {
//This very simple test checks the TRACERS_EXPECTED_PROVIDER env var, and if set, asserts that
//the tracing implementation compiled into this library matches the expected one. In
//practice this is only used by the CI builds to verify that the compile-time magic always
//ends up with the expeced implementation on a variety of environments
if let Ok(expected_impl) = std::env::var("TRACERS_EXPECTED_PROVIDER") {
match init_provider!(TestProbes) {
Err(e) => panic!("Provider initialization error: {}", e),
Ok(details) => assert_eq!(expected_impl, details),
}
}
}
================================================
FILE: tracers-build/Cargo.toml
================================================
[package]
name = "tracers-build"
version = "0.2.0"
authors = ["Adam Nelson <anelson@127.io>"]
edition = "2018"
license = "MIT OR Apache-2.0"
description = """
Implements the compile-time code generation of the tracers in a crate. This crate should be a `build-dependencies`
dependency of alll crates that use `tracers`. See the `tracers` crate for documentation and instructions.
"""
repository = "https://github.com/anelson/tracers"
[dependencies]
tracers-codegen = { path = "../tracers-codegen", version = "0.2.0" }
================================================
FILE: tracers-build/src/lib.rs
================================================
//! Simply re-exports the build-related functions in `tracers-codegen`
pub use tracers_codegen::{build, tracers_build};
pub use tracers_codegen::{TracersError, TracersResult};
================================================
FILE: tracers-codegen/Cargo.toml
================================================
[package]
name = "tracers-codegen"
version = "0.2.0"
authors = ["Adam Nelson <anelson@127.io>"]
edition = "2018"
license = "MIT OR Apache-2.0"
description = """
Contains the compile-time code generation logic which powers the `probe` and `tracers` macros.
Do not use this crate directly; see "tracers" for more information.
"""
repository = "https://github.com/anelson/tracers"
[dependencies]
askama = "0.8.0"
cargo_metadata = "0.9.0"
cc = "1.0.47"
darling = "0.10.2"
failure = "0.1.6"
heck = "0.3.1"
lazy_static = "1.4.0"
once_cell = "1.2.0"
pkg-config = "0.3.17"
proc-macro-crate = "0.1"
proc-macro2 = "1"
quote = "1"
serde = { version = "1.0.102", features = ["derive"] }
serde_json = "1.0.41"
serde_str = "0.1.0"
strum = "0.16.0"
strum_macros = "0.16.0"
tempfile = "3.1.0"
twox-hash = "1.5.0"
tracers-core = { path = "../tracers-core", version = "0.2.0" }
[dependencies.syn]
# We need some optional features of syn in order to implement the macro
version = "1.0.8"
features = ["full", "visit", "parsing", "extra-traits"]
[features]
default = []
experimental = []
[dev-dependencies]
fs_extra = "1.1.0"
quickcheck = "0.9.0"
quickcheck_macros = "0.8.0"
tempfile = "3.1.0"
[target.'cfg(windows)'.dev-dependencies]
# Need to use Dunce to de-UNC the canonicalized paths on Windows
dunce = "1.0.0"
================================================
FILE: tracers-codegen/src/argtypes.rs
================================================
//! Almost all of the probing code takes advantage of Rust's type system to ensure any type passed
//! to a probe can be represented as a C type, and that the appropriate conversion, if any, is
//! applied before calling the C code.
//!
//! Except, unfortunately, in the code that operates on a Rust AST as represented by `syn`. This
//! isn't actually compiled Rust, it's only parsed Rust, so something like `Option<&str>` doesn't
//! have a type, it's basically just a slightly more structured version of a string.
//!
//! Thus, in order to resolve a `syn::Type` to a corresponding Rust type requires some manual
//! hard-coding work. That work is done here.
//!
//! Anyone who is extending this crate to support additional types, or even just type aliases, must
//! update the `from_syn_type` function accordingly
use crate::serde_helpers;
use serde::{Deserialize, Serialize};
use std::ffi::{CStr, CString};
#[cfg(unix)]
use std::ffi::{OsStr, OsString};
use syn::parse_quote;
use tracers_core::argtypes::*;
use tracers_core::{ProbeArgType, ProbeArgWrapper};
macro_rules! maybe_type {
($syn_t:expr, $rust_t:ty) => {
let rust_syn_t: syn::Type = parse_quote! { $rust_t };
if *$syn_t == rust_syn_t {
return Some(ArgTypeInfo::new::<$rust_t>());
}
};
(@naked $syn_t:expr, $rust_t:ty) => {
maybe_type!($syn_t, $rust_t);
};
(@ref $syn_t:expr, $rust_t:ty) => {
maybe_type!($syn_t, &$rust_t);
};
(@opt $syn_t:expr, $rust_t:ty) => {
maybe_type!($syn_t, &Option<$rust_t>);
};
(@opt_ref $syn_t:expr, $rust_t:ty) => {
maybe_type!($syn_t, &Option<&$rust_t>);
};
(@ptr $syn_t:expr, $rust_t:ty) => {
maybe_type!($syn_t, *const $rust_t);
};
(@primitive $syn_t:expr, $rust_t:ty) => {
maybe_type!(@naked $syn_t, $rust_t);
maybe_type!(@ref $syn_t, $rust_t);
maybe_type!(@opt $syn_t, $rust_t);
maybe_type!(@opt_ref $syn_t, $rust_t);
maybe_type!(@ptr $syn_t, $rust_t);
};
(@string $syn_t:expr, $rust_t:ty) => {
maybe_type!(@naked $syn_t, $rust_t);
maybe_type!(@opt $syn_t, $rust_t);
};
}
macro_rules! maybe_types {
($syn_t:expr, $($rust_t:ty),+) => {
$(
maybe_type!($syn_t, $rust_t);
)*
};
(@$tag:ident $syn_t:expr, $($rust_t:ty),+) => {
$(
maybe_type!(@$tag $syn_t, $rust_t);
)*
};
}
/// Given a type expression from a Rust AST, tries to get the type information for that type.
/// If it can't be resolved, returns `None`
///
/// This function has a massive cyclomatic complexity due to all of the macro-generated code, but
/// in this case it's safe to ignore the clippy lint.
#[allow(clippy::cognitive_complexity)]
pub(crate) fn from_syn_type(ty: &syn::Type) -> Option<ArgTypeInfo> {
//TODO: There HAS to be a better and more performant way to do this, but working with the syn
//type hierarchy directly is just agony
maybe_types!(@primitive ty, i8, u8, i16, u16, i32, u32, i64, u64, usize, isize);
maybe_types!(@string ty, &str, &String);
#[cfg(unix)] // Only the unix impl of OsStr/OsString exposes the string as bytes
maybe_types!(@string ty, &OsStr, &OsString);
maybe_types!(@string ty, &CStr, &CString);
maybe_type!(@primitive ty, bool);
//Else, this isn't a type we recognize
None
}
#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
pub(crate) struct ArgTypeInfo {
#[serde(with = "serde_helpers::string")]
c_type: CType,
c_type_str: String,
rust_type_str: String,
}
#[allow(dead_code)] //TODO: temporary
impl ArgTypeInfo {
pub fn new<T: ProbeArgType<T>>() -> ArgTypeInfo {
ArgTypeInfo {
c_type: <<<T as ProbeArgType<T>>::WrapperType as ProbeArgWrapper>::CType as ProbeArgNativeTypeInfo>::get_c_type(),
c_type_str: <<<T as ProbeArgType<T>>::WrapperType as ProbeArgWrapper>::CType as ProbeArgNativeTypeInfo>::get_c_type_str().to_owned(),
rust_type_str: <<<T as ProbeArgType<T>>::WrapperType as ProbeArgWrapper>::CType as ProbeArgNativeTypeInfo>::get_rust_type_str().to_owned()
}
}
/// Gets the `CType` enum which corresponds to the C data type which is used to represent this
/// type when calling probes
pub fn get_c_type_enum(&self) -> CType {
self.c_type.clone()
}
/// Gets a string which contains the C type for use generating C/C++ code. For example if the
/// `CType` is `VoidPtr`, this function returns `void *`
pub fn get_c_type_str(&self) -> &str {
&self.c_type_str
}
/// Gets a string containing the Rust type corresponding to the native C type. This also is
/// used for generating code. It corresponds directly to the type which the `ProbeArgWrapper`
/// returns and passes to the auto-generated Rust bindings.
///
/// That means that as long as each of the C types in `get_c_type_str` correctly match the
/// corresponding Rust types returned by this function, the Rust type system will ensure there
/// are no errors.
///
/// For example, if somewhere else in the code we have a bug whereby `&str` is passed as
/// `void*`, but this code thinks it should be `char*`, when Rust compiles the call to the
/// generated Rust bindings it will fail.
pub fn get_rust_type_str(&self) -> &str {
&self.rust_type_str
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::testdata::*;
macro_rules! test_type {
($rust_t:ty, $c_type:expr, $rust_type_str:expr) => {
let syn_typ: syn::Type = parse_quote! { $rust_t };
assert_eq!(
Some(ArgTypeInfo {
c_type: $c_type,
c_type_str: $c_type.to_string(),
rust_type_str: $rust_type_str.to_string(),
}),
from_syn_type(&syn_typ),
"Got unexpected arg type info for type expression '{}'", stringify!($rust_t)
);
};
(@naked $rust_t:ty, $c_type:expr, $rust_type_str:expr) => {
test_type!($rust_t, $c_type, $rust_type_str);
};
// Primitive types marshal refs the same as the value type
(@primitive_ref $rust_t:ty, $c_type:expr, $rust_type_str:expr) => {
test_type!(&$rust_t, $c_type, $rust_type_str);
};
// Primitive types marshal optionals the same as the value type (using the default value
// for None)
(@primitive_opt $rust_t:ty, $c_type:expr, $rust_type_str:expr) => {
test_type!(&Option<$rust_t>, $c_type, $rust_type_str);
};
// Primitive types marshal Option<&..> the same also
(@primitive_opt_ref $rust_t:ty, $c_type:expr, $rust_type_str:expr) => {
test_type!(&Option<&$rust_t>, $c_type, $rust_type_str);
};
// Primitive pointers are just cast to void pointers, except for the char types
(@primitive_ptr $rust_t:ty, $c_type:expr, $rust_type_str:expr) => {
test_type!(*const $rust_t, CType::VoidPtr, "*const std::os::raw::c_void");
};
(@primitive_ptr i8, $c_type:expr, $rust_type_str:expr) => {
test_type!(*const $rust_t, CType::CharPtr, "*const std::os::raw::c_char");
};
(@primitive_ptr u8, $c_type:expr, $rust_type_str:expr) => {
test_type!(*const $rust_t, CType::UCharPtr, "*const std::os::raw::c_uchar");
};
(@primitive $rust_t:ty, $c_type:expr, $rust_type_str:expr) => {
test_type!(@naked $rust_t, $c_type, $rust_type_str);
test_type!(@primitive_ptr $rust_t, $c_type, $rust_type_str);
test_type!(@primitive_ref $rust_t, $c_type, $rust_type_str);
test_type!(@primitive_opt $rust_t, $c_type, $rust_type_str);
test_type!(@primitive_opt_ref $rust_t, $c_type, $rust_type_str);
};
(@string $rust_t:ty, $c_type:expr, $rust_type_str:expr) => {
test_type!(@naked $rust_t, $c_type, $rust_type_str);
test_type!(@primitive_opt $rust_t, $c_type, $rust_type_str);
};
}
#[test]
fn test_type_support() {
// This is only complex because the macros expand into complex code. For readability
// it's fine
#![allow(clippy::cognitive_complexity)]
test_type!(@primitive i8, CType::Char, "std::os::raw::c_char");
test_type!(@primitive u8, CType::UChar, "std::os::raw::c_uchar");
test_type!(@primitive i16, CType::Short, "std::os::raw::c_short");
test_type!(@primitive u16, CType::UShort, "std::os::raw::c_ushort");
test_type!(@primitive i32, CType::Int, "std::os::raw::c_int");
test_type!(@primitive u32, CType::UInt, "std::os::raw::c_uint");
test_type!(@primitive i64, CType::LongLong, "std::os::raw::c_longlong");
test_type!(@primitive u64, CType::ULongLong, "std::os::raw::c_ulonglong");
test_type!(@primitive usize, CType::SizeT, "libc::size_t");
test_type!(@primitive isize, CType::SSizeT, "libc::ssize_t");
test_type!(@primitive bool, CType::Int, "std::os::raw::c_int");
test_type!(@string &str, CType::CharPtr, "*const std::os::raw::c_char");
test_type!(@string &String, CType::CharPtr, "*const std::os::raw::c_char");
#[cfg(unix)] // Only the unix impl of OsStr/OsString exposes the string as bytes
test_type!(@string &OsStr, CType::CharPtr, "*const std::os::raw::c_char");
#[cfg(unix)] // Only the unix impl of OsStr/OsString exposes the string as bytes
test_type!(@string &OsString, CType::CharPtr, "*const std::os::raw::c_char");
test_type!(@string &CStr, CType::CharPtr, "*const std::os::raw::c_char");
test_type!(@string &CString, CType::CharPtr, "*const std::os::raw::c_char");
}
#[test]
fn test_support_for_all_test_traits() {
//Anything in our corpus of valid provider traits should correspond to a known type
//Plus, this way if I ever go and add support for a new type, if I add an example of it to
//the test cases, this test will fail, which will remind me I need to enable support for
//that type here.
for test_trait in
get_test_provider_traits(|t: &TestProviderTrait| t.expected_error.is_none()).into_iter()
{
//The test data don't tell us anything about what the expected C wrapper type of each
//arg will be. Nor should they; that's what this module's tests are for.
//The purpose of this test is to ensure there are no probe args in any of the traits
//which are expected to be valid, that cannot be identified from their `syn::Type`
//representation
for probe in test_trait.probes.unwrap().into_iter() {
for (name, rust_syn_type, c_type) in probe.args.into_iter() {
let arg_type_info = from_syn_type(&rust_syn_type);
assert_ne!(None, arg_type_info,
"test trait '{}' probe '{}' arg '{}' has a type which `from_syn_type` can't identify",
test_trait.description,
probe.name,
name);
let arg_type_info = arg_type_info.unwrap();
assert_eq!(c_type, arg_type_info.get_c_type_enum(),
"test trait '{}' probe '{}' arg '{}' has a type for which `from_syn_type` returned an incorrect `CType` (and, probably, other wrapper types also)",
test_trait.description,
probe.name,
name);
}
}
}
}
}
================================================
FILE: tracers-codegen/src/build_rs.rs
================================================
//! This module contains the code that is used within `tracers`s build.rs` file to select
//! the suitable tracing implementation at build time, and within a dependent crate's `build.rs`
//! file to perform the build-time code generation to support the selected tracing implementation
use crate::cargo;
use crate::error::{TracersError, TracersResult};
use crate::gen;
use crate::gen::NativeLib;
use crate::TracingImplementation;
use failure::ResultExt;
use serde::{Deserialize, Serialize};
use std::env;
use std::fs::File;
use std::io::Write;
use std::io::{BufReader, BufWriter};
use std::path::{Path, PathBuf};
/// Captures the features enabled for the build. There are various combinations of them which
/// influence the logic related to what implementation is preferred
#[derive(Debug, Clone)]
struct FeatureFlags {
enable_dynamic_tracing: bool,
enable_static_tracing: bool,
force_dyn_stap: bool,
force_dyn_noop: bool,
force_static_stap: bool,
force_static_lttng: bool,
force_static_noop: bool,
}
impl FeatureFlags {
/// Read the feature flags from the environment variables set by Cargo at build time.
///
/// Fails with an error if the combination of features is not valid
pub fn from_env() -> TracersResult<FeatureFlags> {
Self::new(
Self::is_feature_enabled("dynamic-tracing"),
Self::is_feature_enabled("static-tracing"),
Self::is_feature_enabled("force-dyn-stap"),
Self::is_feature_enabled("force-dyn-noop"),
Self::is_feature_enabled("force-static-stap"),
Self::is_feature_enabled("force-static-lttng"),
Self::is_feature_enabled("force-static-noop"),
)
}
/// Creates a feature flag structure from explicit arguments. Mostly used for testing
pub fn new(
enable_dynamic_tracing: bool,
enable_static_tracing: bool,
force_dyn_stap: bool,
force_dyn_noop: bool,
force_static_stap: bool,
force_static_lttng: bool,
force_static_noop: bool,
) -> TracersResult<FeatureFlags> {
if enable_dynamic_tracing && enable_static_tracing {
return Err(TracersError::code_generation_error("The features `dynamic-tracing` and `static-tracing` are mutually exclusive; please choose one"));
}
if force_dyn_stap && force_dyn_noop {
return Err(TracersError::code_generation_error("The features `force-dyn-stap` and `force_dyn_noop` are mutually exclusive; please choose one"));
}
if force_static_stap && force_static_noop {
return Err(TracersError::code_generation_error("The features `force-static-stap` and `force_static_noop` are mutually exclusive; please choose one"));
}
if force_static_lttng && force_static_noop {
return Err(TracersError::code_generation_error("The features `force-static-lttng` and `force_static_noop` are mutually exclusive; please choose one"));
}
Ok(FeatureFlags {
enable_dynamic_tracing,
enable_static_tracing,
force_dyn_stap,
force_dyn_noop,
force_static_stap,
force_static_lttng,
force_static_noop,
})
}
pub fn enable_tracing(&self) -> bool {
self.enable_dynamic() || self.enable_static()
}
pub fn enable_dynamic(&self) -> bool {
self.enable_dynamic_tracing || self.force_dyn_noop || self.force_dyn_stap
}
pub fn enable_static(&self) -> bool {
self.enable_static_tracing
}
pub fn force_dyn_stap(&self) -> bool {
//Should the dynamic stap be required on pain of build failure?
self.force_dyn_stap
}
pub fn force_dyn_noop(&self) -> bool {
//Should the dynamic stap be required on pain of build failure?
self.force_dyn_noop
}
pub fn force_static_stap(&self) -> bool {
//Should the staticamic stap be required on pain of build failure?
self.force_static_stap
}
pub fn force_static_lttng(&self) -> bool {
//Should the static lttng be required on pain of build failure?
self.force_static_lttng
}
fn is_feature_enabled(name: &str) -> bool {
env::var(&format!(
"CARGO_FEATURE_{}",
name.to_uppercase().replace("-", "_")
))
.is_ok()
}
}
/// Serializable struct which is populated in `build.rs` to indicate to the proc macros which
/// tracing implementation they should use.
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub(crate) struct BuildInfo {
pub package_name: String,
pub implementation: TracingImplementation,
}
impl BuildInfo {
pub fn new(package_name: String, implementation: TracingImplementation) -> BuildInfo {
BuildInfo {
package_name,
implementation,
}
}
pub fn load() -> TracersResult<BuildInfo> {
let path = Self::get_build_path()?;
let file = File::open(&path)
.map_err(|e| TracersError::build_info_read_error(path.clone(), e.into()))?;
let reader = BufReader::new(file);
serde_json::from_reader(reader)
.map_err(|e| TracersError::build_info_read_error(path.clone(), e.into()))
}
pub fn save(&self) -> TracersResult<PathBuf> {
let path = Self::get_build_path()?;
//Make sure the directory exists
path.parent()
.map(|p| {
std::fs::create_dir_all(p)
.map_err(|e| TracersError::build_info_write_error(path.clone(), e.into()))
})
.unwrap_or(Ok(()))?;
let file = File::create(&path)
.map_err(|e| TracersError::build_info_write_error(path.clone(), e.into()))?;
let writer = BufWriter::new(file);
serde_json::to_writer(writer, self)
.map_err(|e| TracersError::build_info_write_error(path.clone(), e.into()))?;
Ok(path)
}
fn get_build_path() -> TracersResult<PathBuf> {
//HACK: This is...not the most elegant solution. This code gets used in three contexts:
//
//1. When `tracers` itself is being built, its `build.rs` calls into `tracers-build` to
// decide which probing implementation to use based on the feature flags specified by the
// caller. In that case, `OUT_DIR` is set by `cargo` to the out directory for the
// `tracers` crate. In that situation the `BuildInfo` file should go somewhere in
// `$OUT_DIR`, in a subdirectory named with the `tracers` package name and version
//
//2. When some other crate is using `tracers`, its `build.rs` calls into `tracers-build` to
// perform the build-time code generation tasks, which first require knowing which
// implementation `tracers` is using, hence requires reading the `BuildInfo` file. In
// this case, `$OUT_DIR` is set to that dependent crate's output directory and is not
// what we want. We want to know the path to the `BuildInfo` file produced when
// `tracers` was built. Fortunately this information is passed on to the dependent crate
// by `tracers`s `build.rs` in the form of a cargo variable which cargo propagates to
// dependent crates as `DEP_TRACERS_BUILD_INFO_PATH`
//
//3. When one of the proc macros is invoked during compilation of some crate which is using
// `tracers`. In this case, the other crate's `build.rs` should have already been run,
// and it should have called into the `tracers_build::build()` (that call is what creates
// context #2 above). `tracers_build::build()` will instruct Cargo to set an environment
// variable `TRACERS_BUILD_INFO_PATH` during compilation, which this method will then
// example in order to get the path of the `BuidlInfo` build.
//
//I'm not proud of this code. But `tracers` pushes the Rust build system just about to the
//breaking point as it is. We're lucky it's possible at all, hacks notwithstanding
if "tracers" == env::var("CARGO_PKG_NAME").ok().unwrap_or_default() {
//This is context #1 in the comment above: we're being called from within the `tracers`
//build.rs
let rel_path = PathBuf::from(&format!(
"{}-{}/buildinfo.json",
env::var("CARGO_PKG_NAME").context("CARGO_PKG_NAME")?,
env::var("CARGO_PKG_VERSION").context("CARGO_PKG_VERSION")?
));
Ok(PathBuf::from(env::var("OUT_DIR").context("OUT_DIR")?).join(rel_path))
} else if let Ok(build_info_path) = env::var("DEP_TRACERS_BUILD_INFO_PATH") {
//This is context #2 in the comment above
Ok(PathBuf::from(build_info_path))
} else if let Ok(build_info_path) = env::var("TRACERS_BUILD_INFO_PATH") {
//This is context #3 in the comment above
Ok(PathBuf::from(build_info_path))
} else {
//Since the first context happens in the `tracers` code itself and we know it's
//implemented correctly, it means that this is either context #2 or #3 and the caller
//did something wrong. Most likely they forgot to add the call to
//`tracers_build::build()` to their `build.rs`. Since this is an easy mistake to make
//we want an ergonomic error message here
Err(TracersError::missing_call_in_build_rs())
}
}
}
/// Called from the `build.rs` of all crates which have a direct dependency on `tracers` and
/// `tracers_macros`. This determines the compile-time configuration of the `tracers` crate, and
/// performs any build-time code generation necessary to support the code generated by the
/// `tracers_macros` macros.
///
/// It should be the first line in the `main()` function, etc:
///
/// ```no_execute
/// // build.rs
/// use tracers_build::build;
///
/// fn main() {
/// build();
///
/// //....
/// }
/// ```
pub fn build() {
let mut stdout = std::io::stdout();
let mut stderr = std::io::stderr();
match build_internal(&mut stdout) {
Ok(_) => writeln!(stdout, "probes build succeeded").unwrap(),
Err(e) => {
//An error that propagates all the way up to here is serious enough that it means we
//cannot proceed. Fail the build by exiting the process forcefully
writeln!(stderr, "Error building probes: {}", e).unwrap();
std::process::exit(-1);
}
};
}
fn build_internal<OUT: Write>(out: &mut OUT) -> TracersResult<()> {
//First things first; get the BuildInfo from the `tracers` build, and tell Cargo to make that
//available to the proc macros at compile time via an environment variable
let build_info_path = BuildInfo::get_build_path()?;
writeln!(
out,
"cargo:rustc-env=TRACERS_BUILD_INFO_PATH={}",
build_info_path.display()
)
.unwrap();
generate_native_code(out)
}
/// This function is the counterpart to `build`, which is intended to be invoked in the `tracers`
/// `build.rs` script. It reads the feature flags enabled on `tracers`, and from those flags and
/// other information about the target sytem and the local build environment selects an
/// implementation to use, or panics if no suitable implementation is possible
pub fn tracers_build() {
let mut stdout = std::io::stdout();
let mut stderr = std::io::stderr();
let features = FeatureFlags::from_env().expect("Invalid feature flags");
match tracers_build_internal(&mut stdout, features) {
Ok(_) => {}
Err(e) => {
//failure here doesn't just mean one of the tracing impls failed to compile; when that
//happens we can always fall back to the no-op impl. This means something happened
//which prevents us from proceeding with the build
writeln!(stderr, "{}", e).unwrap();
panic!("tracers build failed: {}", e);
}
}
}
fn tracers_build_internal<OUT: Write>(out: &mut OUT, features: FeatureFlags) -> TracersResult<()> {
writeln!(out, "Detected features: \n{:?}", features).unwrap();
select_implementation(&features).map(|implementation| {
// Some implementation was selected, but it's possible that the selected
// "implementation" is to completely disable tracing. If that's not the case, set the
// appropriate features for the compiler to use when compiling the `tracers` code.
if implementation.is_enabled() {
writeln!(out, "cargo:rustc-cfg=enabled").unwrap();
writeln!(out,
"cargo:rustc-cfg={}_enabled",
if implementation.is_static() {
"static"
} else {
"dynamic"
}
).unwrap(); //this category of tracing is enabled
writeln!(out, "cargo:rustc-cfg={}_enabled", implementation.as_ref()).unwrap(); //this specific impl is enabled
}
//All downstream creates from `tracers` will just call `tracers_build::build`, but this
//is a special case because we've already decided above which implementation to use.
//
//This decision needs to be saved to the OUT_DIR somewhere, so that all of our tests,
//examples, binaries, and benchmarks which use the proc macros will be able to generate
//the correct runtime tracing code to match the implementation we've chosen here
let build_info = BuildInfo::new(env::var("CARGO_PKG_NAME").expect("CARGO_PKG_NAME"), implementation);
match build_info.save() {
Ok(build_info_path) => {
//The above statements set compile-time features to the compiler knows which modules to
//include. The below will set environment variables DEP_TRACERS_(VARNAME) in dependent
//builds
//
//The codegen stuff in `tracers_build::build` will use this to determine what code
//generator to use
writeln!(out, "cargo:build-info-path={}", build_info_path.display()).unwrap();
}
Err(e) => {
writeln!(out, "cargo:warning=Error saving build info file; some targets may fail to build. Error details: {}", e).unwrap();
}
}
})?;
//Generate native code for the `tracers` crate. Nothing in the actual `tracers`
//library code contains any `#[tracer]` traits, but the tests and examples do, so if we
//want them to work propertly we need to run codegen for them just like on any other
//crate
generate_native_code(out)
}
/// Selects a `tracers` implementation given a set of feature flags specified by the user
fn select_implementation(features: &FeatureFlags) -> TracersResult<TracingImplementation> {
if !features.enable_tracing() {
return Ok(TracingImplementation::Disabled);
}
//If any implementation is forced, then see if it's available and if so then accept it
if features.enable_dynamic() {
// Pick some dynamic tracing impl
if features.force_dyn_stap() {
if env::var("DEP_TRACERS_DYN_STAP_SUCCEEDED").is_err() {
return Err(TracersError::code_generation_error(
"force-dyn-stap is enabled but the dyn_stap library is not available",
));
} else {
return Ok(TracingImplementation::DynamicStap);
}
} else if features.force_dyn_noop() {
//no-op is always available on all platforms
return Ok(TracingImplementation::DynamicNoOp);
}
//Else no tracing impl has been forced so we get to decide
if env::var("DEP_TRACERS_DYN_STAP_SUCCEEDED").is_ok() {
//use dyn_stap when it savailable
Ok(TracingImplementation::DynamicStap)
} else {
//else, fall back to noop
Ok(TracingImplementation::DynamicNoOp)
}
} else {
// Pick some static tracing impl
assert!(features.enable_static());
//TODO: Be a bit smarter about this
if features.force_static_stap() {
Ok(TracingImplementation::StaticStap)
} else if features.force_static_lttng() {
Ok(TracingImplementation::StaticLttng)
} else {
Ok(TracingImplementation::StaticNoOp)
}
}
}
fn generate_native_code(out: &mut dyn Write) -> TracersResult<()> {
let manifest_dir = env::var("CARGO_MANIFEST_DIR").context(
"CARGO_MANIFEST_DIR is not set; are you sure you're calling this from within build.rs?",
)?;
let manifest_path = PathBuf::from(manifest_dir).join("Cargo.toml");
let package_name = env::var("CARGO_PKG_NAME").unwrap();
let targets = cargo::get_targets(&manifest_path, &package_name).context("get_targets")?;
let out_path = &PathBuf::from(env::var("OUT_DIR").context("OUT_DIR")?);
let mut native_libs = gen::code_generator()?.generate_native_code(
out,
&Path::new(&manifest_path),
&out_path,
&package_name,
targets,
);
//There is usually some repetition when multiple providers are generated. Filter that out for
//better build performance
native_libs.sort_by(|a, b| a.partial_cmp(b).unwrap());
native_libs.dedup();
//Scan through all of the native libs output and send the info to cargo as applicable
for native_lib in native_libs.into_iter() {
match native_lib {
NativeLib::StaticWrapperLib(_) => {
//This is the name of a generated native wrapper. Ignore it here; the `tracers`
//attribute macro will use this to generate a `link` attribute at the actual call
//site
}
NativeLib::StaticWrapperLibPath(path) | NativeLib::SupportLibPath(path) => {
//This is the path to a directory where either the static wrapper or a support lib
//will be found. Make sure cargo adds that to the library path
println!("cargo:rustc-link-search=native={}", path.display());
}
NativeLib::DynamicSupportLib(lib) => {
//This is a dynamically-linked support library which should be linked exactly once
//for the crate, to support any number of generated native wrappers
println!("cargo:rustc-link-lib=dylib={}", lib);
}
NativeLib::StaticSupportLib(lib) => {
//This is a statically-linked support library which should be linked exactly once
//for the crate, to support any number of generated native wrappers
println!("cargo:rustc-link-lib=static={}", lib);
}
};
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::testdata;
use crate::TracingType;
#[test]
#[should_panic]
fn tracers_build_panics_invalid_features() {
//These two feature flags are mutually exclusive
let guard = testdata::with_env_vars(vec![
("CARGO_FEATURE_STATIC_TRACING", "1"),
("CARGO_FEATURE_DYNAMIC_TRACING", "1"),
]);
tracers_build();
drop(guard);
}
#[test]
fn build_rs_workflow_tests() {
// Simulates the entire process, starting with `tracers_build` choosing an implementation
// based on the selected feature flags, then the dependent crate calling `build` to query
// the build info generated by `tracers_build` and to perform perform
// pre-processing of its code, then the proc macros reading the build info persisted by
// `build` to generate the right implementation.
//
// This doesn't actually integrate all those systems in a test, but it simulates the
// relevant calls into the `build_rs` code
let test_cases = vec![
//features, expected_impl
(
// Tracing disabled entirely
FeatureFlags::new(false, false, false, false, false, false, false).unwrap(),
TracingImplementation::Disabled,
),
(
// Tracing enabled, dynamic mode enabled with auto-detect, static disabled
FeatureFlags::new(true, false, false, false, false, false, false).unwrap(),
TracingImplementation::DynamicNoOp,
),
(
// Tracing enabled, dynamic disabled, static enabled with auto-detect
FeatureFlags::new(false, true, false, false, false, false, false).unwrap(),
TracingImplementation::StaticNoOp,
),
(
// Tracing enabled, dynamic disabled, static enabled with force-static-noop
FeatureFlags::new(false, true, false, false, false, false, true).unwrap(),
TracingImplementation::StaticNoOp,
),
(
// Tracing enabled, dynamic disabled, static enabled with force-static-stap
FeatureFlags::new(false, true, false, false, true, false, false).unwrap(),
TracingImplementation::StaticStap,
),
(
// Tracing enabled, dynamic disabled, static enabled with force-static-lttng
FeatureFlags::new(false, true, false, false, false, true, false).unwrap(),
TracingImplementation::StaticLttng,
),
];
let temp_dir = tempfile::tempdir().unwrap();
let manifest_dir = env!("CARGO_MANIFEST_DIR");
let out_dir = temp_dir.path().join("out");
for (features, expected_impl) in test_cases.into_iter() {
let context = format!(
"features: {:?}\nexpected_impl: {}",
features,
expected_impl.as_ref()
);
//First let's pretend we're in `tracers/build.rs`, and cargo has set the relevant env
//vars
let guard = testdata::with_env_vars(vec![
("CARGO_PKG_NAME", "tracers"),
("CARGO_PKG_VERSION", "1.2.3"),
("CARGO_MANIFEST_DIR", manifest_dir),
("OUT_DIR", out_dir.to_str().unwrap()),
]);
let mut stdout = Vec::new();
tracers_build_internal(&mut stdout, features.clone()).unwrap_or_else(|_| {
panic!(format!("Unexpected failure with features: {:?}", features))
});
//That worked. The resulting build info should have been written out
let build_info_path = BuildInfo::get_build_path().unwrap();
let step1_build_info = BuildInfo::load().unwrap_or_else(|_| {
panic!(format!(
"Failed to load build info for features: {:?}",
features
))
});
assert_eq!(
expected_impl, step1_build_info.implementation,
"context: {}",
context
);
//And the path to this should have been written to stdout such that cargo will treat it
//as a variable that is passed to dependent crates' `build.rs`:
let output = String::from_utf8(stdout).unwrap();
assert!(
output.contains(&format!(
"cargo:build-info-path={}",
build_info_path.display()
)),
context
);
//and the features used to compile `tracers` should correspond to the implementation
match expected_impl.tracing_type() {
TracingType::Disabled => assert!(!output.contains("enabled")),
TracingType::Dynamic => assert!(output.contains("cargo:rustc-cfg=dynamic_enabled")),
TracingType::Static => assert!(output.contains("cargo:rustc-cfg=static_enabled")),
}
if expected_impl.is_enabled() {
assert!(
output.contains(&format!(
"cargo:rustc-cfg={}_enabled",
expected_impl.as_ref()
)),
context
);
}
//Next, the user crate's `build.rs` will want to know what the selected impl was
drop(guard);
let guard = testdata::with_env_vars(vec![
(
"DEP_TRACERS_BUILD_INFO_PATH",
build_info_path.to_str().unwrap(),
),
("OUT_DIR", out_dir.to_str().unwrap()),
]);
let step2_build_info = BuildInfo::load().unwrap_or_else(|_| {
panic!(format!(
"Failed to load build info for features: {:?}",
features
))
});
assert_eq!(step1_build_info, step2_build_info, "context: {}", context);
drop(guard);
//At this point in the process if this were a real build, the `build.rs` code would be
//generating code for a real crate. We're not going to simulate all of that here,
//however we can invoke the code gen for all of our test crates at this point, and the
//code gen should work using the currently selected implementatoin
for test_case in testdata::TEST_CRATES.iter() {
let context = format!(
"features: {:?} test_case: {}",
features,
test_case.root_directory.display()
);
let mut stdout = Vec::new();
let guard = testdata::with_env_vars(vec![
(
"DEP_TRACERS_BUILD_INFO_PATH",
build_info_path.to_str().unwrap(),
),
("OUT_DIR", out_dir.to_str().unwrap()),
("CARGO_PKG_NAME", test_case.package_name),
(
"CARGO_MANIFEST_DIR",
test_case.root_directory.to_str().unwrap(),
),
("TARGET", "x86_64-linux-gnu"),
("HOST", "x86_64-linux-gnu"),
("OPT_LEVEL", "1"),
]);
build_internal(&mut stdout).expect(&context);
//After the build, it should output something on stdout to tell Cargo to set a
//compiler-visible env var telling the proc macros where the `BuildInfo` file is
let output = String::from_utf8(stdout).unwrap();
assert!(output.contains(&format!(
"cargo:rustc-env=TRACERS_BUILD_INFO_PATH={}",
build_info_path.display()
)));
drop(guard);
}
//That worked, next the proc macros will be run by `rustc` while it builds the user
//crate.
let guard = testdata::with_env_vars(vec![(
"TRACERS_BUILD_INFO_PATH",
build_info_path.to_str().unwrap(),
)]);
let step3_build_info = BuildInfo::load().unwrap_or_else(|_| {
panic!(format!(
"Failed to load build info for features: {:?}",
features
))
});
assert_eq!(step1_build_info, step3_build_info, "context: {}", context);
drop(guard);
}
}
}
================================================
FILE: tracers-codegen/src/cache.rs
================================================
//! Implements a simple filesystem-based caching system, where the results of idempotent
//! computations on either filesystem or `TokenStream` inputs are cached in a file system directory
//! (intended to be the `OUT_DIR` of a Cargo build).
use crate::hashing::*;
use failure::{bail, format_err, Fallible};
use serde::{de::DeserializeOwned, Serialize};
use std::fs::File;
use std::io::Read;
use std::io::{BufReader, BufWriter};
use std::path::{Path, PathBuf};
use std::str;
/// Given the path to a file, and a function that takes as an argument a `String` with the contents
/// of that file and returns the (serializable) result of some computation on those contents,
/// implements a cache whereby first the cache directory is checked to see if a previous operation
/// has been attempted on the same file contents. If found, that version is returned and the
/// function is never invoked.
pub(crate) fn cache_file_computation<
T: Serialize + DeserializeOwned,
F: FnOnce(&str) -> Fallible<T>,
>(
cache_path: &Path,
input_path: &Path,
key: &str,
f: F,
) -> Fallible<T> {
//NB: astute readers may notice that this unconditionally loads and hashes the input file,
//without trying to check if the date/time metadata are older than the latest cached entry.
//This is intentional. It simplifies the code, and the hashing algorithm we use runs at 6GB/s
//on a crappy Core i5 (https://github.com/Cyan4973/xxHash). For the kind of workloads are are
//caching, that's a rounding error
let mut file = File::open(input_path)?;
let mut content = Vec::new();
file.read_to_end(&mut content)?;
let hash = hash_buf(&content);
let results_path = cached_results_path(input_path, key, hash);
//Try to load a cached results file. If it doesn't exist or there's any kind of error loading
//it, just invoke the function again
let abs_path = cache_generated_file(cache_path, &results_path, |abs_path| {
str::from_utf8(&content)
.map_err(|e| {
format_err!(
"Input file {} contains invalid UTF-8 text: {}",
results_path.display(),
e
)
})
.and_then(|str_contents| f(str_contents))
.and_then(|result| {
//Result was computed; serialize it back
save_results::<T>(&abs_path, &result).and(Ok(abs_path))
})
})?;
load_cached_results::<T>(&abs_path)
}
/// Similar to `cache_file_computation`, except the computation is not on the contents of a file
/// but rather on some arbitrary object with a name and a hash. If the computation has previously
/// been performed on the same name and hash, the previous result is returned. Otherwise the
/// computation is performed and saved in the cache for future invocations.
pub(crate) fn cache_object_computation<
T: Serialize + DeserializeOwned,
F: FnOnce() -> Fallible<T>,
>(
cache_path: &Path,
object_name: &str,
hash: HashCode,
key: &str,
f: F,
) -> Fallible<T> {
//Just like the file scenario, use the object's hash to detect changes
let results_path = cached_results_path(Path::new(object_name), key, hash);
//Try to load a cached results file. If it doesn't exist or there's any kind of error loading
//it, just invoke the function again
let abs_path = cache_generated_file(cache_path, &results_path, |abs_path| {
f().and_then(|result| {
//Result was computed; serialize it back
save_results::<T>(&abs_path, &result).and(Ok(abs_path))
})
})?;
load_cached_results::<T>(&abs_path)
}
/// Identical to `cache_object_computation` except this is read-only; if the computation does not
/// exist in the cache it returns an error
pub(crate) fn get_cached_object_computation<T: Serialize + DeserializeOwned>(
cache_path: &Path,
object_name: &str,
hash: HashCode,
key: &str,
) -> Fallible<T> {
//Just like the file scenario, use the object's hash to detect changes
let results_path = cached_results_path(Path::new(object_name), key, hash);
//Try to load a cached results file. If it doesn't exist or there's any kind of error loading
//it, just invoke the function again
let abs_path = cache_path.join(results_path);
load_cached_results::<T>(&abs_path)
}
/// Lower-level caching function. Given some arbitrary file name (and optional path components)
/// relative to the cache path, if the file exists, returns the fully qualified path to the file in
/// the cache, if not, it passes that fully qualified path to the provided closure, and if that
/// closure succeeds and the file was created, then this function returns the fully qualified path.
///
/// If the closure returns an error, or if it returns success but the file still doesn't exist,
/// this function fails
pub(crate) fn cache_generated_file<F: FnOnce(PathBuf) -> Fallible<PathBuf>>(
cache_path: &Path,
results_path: &Path,
f: F,
) -> Fallible<PathBuf> {
let abs_path = cache_path.join(results_path);
if abs_path.exists() {
Ok(abs_path)
} else {
let abs_path = f(abs_path)?;
if abs_path.exists() {
Ok(abs_path)
} else {
bail!(
"The result file {} was not created as expected",
abs_path.display()
)
}
}
}
/// Given the path to some root directory, generates a path to a subdirectory which is suitable for
/// use as a cache. This automatically adds the version of the crate to the path to ensure caches
/// are invalidated whenever a new version is released
pub(crate) fn get_cache_path(root: &Path) -> PathBuf {
let mut root = root.to_owned();
root.push(concat!(
env!("CARGO_PKG_NAME"),
"-",
env!("CARGO_PKG_VERSION")
));
root.push("cache");
root
}
fn load_cached_results<T: Serialize + DeserializeOwned>(results_path: &Path) -> Fallible<T> {
let file = File::open(results_path)?;
let reader = BufReader::new(file);
serde_json::from_reader(reader).map_err(std::convert::Into::into) //convert the error to a failure-compatible type
}
fn save_results<T: Serialize + DeserializeOwned>(results_path: &Path, results: &T) -> Fallible<()> {
//Make sure the directory exists
results_path
.parent()
.map(|p| {
std::fs::create_dir_all(p)
.map_err(|e| format_err!("Error creating output directory {}: {}", p.display(), e))
})
.unwrap_or(Ok(()))?;
let file = File::create(results_path).map_err(|e| {
format_err!(
"Error creating cached results file {}: {}",
results_path.display(),
e
)
})?;
let writer = BufWriter::new(file);
serde_json::to_writer(writer, results).map_err(|e| {
format_err!(
"Error saving cached results to {}: {}",
results_path.display(),
e
)
})
}
/// Compute the path of the directory within the cache path which contains all results related to a
/// specific input path and hash.
fn cached_results_path(input_path: &Path, key: &str, hash: HashCode) -> PathBuf {
//There is no need to preseve the entire input path. If the hashes match then they have the
//same content; we include the file name of the input path only to aid in debugging
let input_with_hash = add_hash_to_path(input_path, hash);
let input_name = input_with_hash
.file_name()
.expect("Input path is missing a file name");
PathBuf::from(input_name).join(format!("{}.json", key))
}
#[cfg(test)]
mod test {
use super::*;
use serde::Deserialize;
use std::io::Write;
#[derive(Deserialize, Serialize, Debug)]
struct TestResult {
answer: usize,
}
#[test]
fn caches_file_results() {
let key = "mylib.c";
let root_dir = tempfile::tempdir().unwrap();
let cache_dir = get_cache_path(root_dir.path());
let data_dir = root_dir.path().join("data");
let input_path = data_dir.join("input.txt");
std::fs::create_dir_all(&data_dir).unwrap();
let mut input_file = File::create(&input_path).unwrap();
write!(&mut input_file, "Fear is the mind killer").unwrap();
drop(input_file);
let mut compute_count: usize = 0;
//Invoke the computation for the first time; closure should be called and the result saved
let result: TestResult = cache_file_computation(&cache_dir, &input_path, key, |input| {
compute_count += 1;
Ok(TestResult {
answer: input.len(),
})
})
.unwrap();
assert_eq!(1, compute_count);
assert_eq!("Fear is the mind killer".len(), result.answer);
//Now invoke again; the result should have been cached
let result: TestResult = cache_file_computation(&cache_dir, &input_path, key, |input| {
compute_count += 1;
Ok(TestResult {
answer: input.len(),
})
})
.unwrap();
assert_eq!(1, compute_count);
assert_eq!("Fear is the mind killer".len(), result.answer);
//Now overwrite the contents of the input file and expect the result to be re-computed
let mut input_file = File::create(&input_path).unwrap();
write!(&mut input_file, "I will face my fear").unwrap();
drop(input_file);
let result: TestResult = cache_file_computation(&cache_dir, &input_path, key, |input| {
compute_count += 1;
Ok(TestResult {
answer: input.len(),
})
})
.unwrap();
assert_eq!(2, compute_count);
assert_eq!("I will face my fear".len(), result.answer);
//Finally, put back the original content. The cached result from that version should still
//be on the filesystem and should still be used
let mut input_file = File::create(&input_path).unwrap();
write!(&mut input_file, "Fear is the mind killer").unwrap();
drop(input_file);
//Invoke the computation for the first time; closure should be called and the result saved
let result: TestResult = cache_file_computation(&cache_dir, &input_path, key, |input| {
compute_count += 1;
Ok(TestResult {
answer: input.len(),
})
})
.unwrap();
assert_eq!(2, compute_count);
assert_eq!("Fear is the mind killer".len(), result.answer);
}
#[test]
fn caches_objects_results() {
let key = "mylib.c";
let root_dir = tempfile::tempdir().unwrap();
let cache_dir = root_dir.path().join("cache");
let hash_foo1: HashCode = 5;
let hash_foo2: HashCode = 6;
let mut compute_count: usize = 0;
//Invoke the computation for the first time; closure should be called and the result saved
let result: TestResult =
cache_object_computation(&cache_dir, "foo", hash_foo1, key, || {
compute_count += 1;
Ok(TestResult {
answer: hash_foo1 as usize,
})
})
.unwrap();
assert_eq!(1, compute_count);
assert_eq!(hash_foo1 as usize, result.answer);
//Now invoke again; the result should have been cached
let result: TestResult =
cache_object_computation(&cache_dir, "foo", hash_foo1, key, || {
compute_count += 1;
Ok(TestResult {
answer: hash_foo1 as usize,
})
})
.unwrap();
assert_eq!(1, compute_count);
assert_eq!(hash_foo1 as usize, result.answer);
//Now use another object with a different hash; a new result should be computed
let result: TestResult =
cache_object_computation(&cache_dir, "foo", hash_foo2, key, || {
compute_count += 1;
Ok(TestResult {
answer: hash_foo2 as usize,
})
})
.unwrap();
assert_eq!(2, compute_count);
assert_eq!(hash_foo2 as usize, result.answer);
//Finally, use another instance of the object that should have the same content, and
//thus use the cached result
let result: TestResult =
cache_object_computation(&cache_dir, "foo", hash_foo1, key, || {
compute_count += 1;
Ok(TestResult {
answer: hash_foo1 as usize,
})
})
.unwrap();
assert_eq!(2, compute_count);
assert_eq!(hash_foo1 as usize, result.answer);
}
#[test]
fn caches_generated_data() {
let key = "mylib.c";
let root_dir = tempfile::tempdir().unwrap();
let cache_dir = root_dir.path().join("cache");
let hash_foo1: HashCode = 5;
//Query the cached computation. It's not happened yet so that should be an error
let result: Fallible<TestResult> =
get_cached_object_computation(&cache_dir, "foo", hash_foo1, key);
assert!(result.is_err());
//Invoke the computation for the first time; closure should be called and the result saved
cache_object_computation(&cache_dir, "foo", hash_foo1, key, || {
Ok(TestResult {
answer: hash_foo1 as usize,
})
})
.unwrap();
//Now the computation is cached; it should return
let result: Fallible<TestResult> =
get_cached_object_computation(&cache_dir, "foo", hash_foo1, key);
assert!(result.is_ok());
assert_eq!(hash_foo1 as usize, result.unwrap().answer);
}
}
================================================
FILE: tracers-codegen/src/cargo.rs
================================================
use cargo_metadata::MetadataCommand;
use failure::{format_err, Fallible};
use std::path::Path;
use std::path::PathBuf;
/// Given the path to a Cargo manifest and the name of a package, invokes `cargo metadata` and
/// parses the output to find all of the targets of that package.
///
/// If successful, returns a `Vec` of `Path`s, each the entry point of one of the package's
/// targets.
pub(crate) fn get_targets(manifest_path: &Path, package_name: &str) -> Fallible<Vec<PathBuf>> {
let mut cmd = MetadataCommand::new();
let metadata = cmd
.manifest_path(&manifest_path)
.no_deps()
.exec()
.map_err(|e| format_err!("cargo metadata invocation failed: {}", e))?;
//Find this specific package
let package = metadata
.packages
.iter()
.find(|p| p.name == package_name)
.ok_or_else(|| format_err!("Unable to find package {} in cargo metadata", package_name))?;
Ok(package.targets.iter().map(|t| t.src_path.clone()).collect())
}
#[cfg(test)]
mod test {
use super::*;
use crate::testdata::*;
#[test]
fn gets_correct_targets() {
for case in TEST_CRATES.iter() {
let mut expected_targets: Vec<_> = case
.targets
.iter()
.map(|t| case.root_directory.join(t.entrypoint))
.collect();
let mut targets = get_targets(
&case.root_directory.join(PathBuf::from("Cargo.toml")),
case.package_name,
)
.unwrap();
expected_targets.sort();
targets.sort();
assert_eq!(expected_targets, targets);
}
}
}
================================================
FILE: tracers-codegen/src/deps.rs
================================================
//! This module contains logic that looks into the AST of a Rust source file and finds dependent
//! source files. By "dependent" is meant source file dependencies within the crate, primarily
//! `mod` statements incorporating submodules, but this will also at some point try to follow
//! `include!` macros where possible.
use failure::{bail, Fallible};
use serde::{Deserialize, Serialize};
use std::path::{Path, PathBuf};
use syn::visit::Visit;
/// The type of source dependency.
#[derive(Serialize, Deserialize, Debug)]
pub(crate) enum SourceDependency {
/// A `mod` dependency, specifying the name of the module.
Mod(String),
}
/// Scans an already-parsed AST and finds the source dependencies within the file
pub(crate) fn get_dependencies(contents: &syn::File) -> Vec<SourceDependency> {
let mut visitor = Visitor::new();
visitor.visit_file(contents);
visitor.deps
}
/// Given the path to a source file and a previously-discovered dependency, attempts to resolve
/// that dependency to an existing source file.
pub(crate) fn resolve_dependency(source_path: &Path, dep: &SourceDependency) -> Fallible<PathBuf> {
match dep {
SourceDependency::Mod(module_name) => find_module(source_path, &module_name),
}
}
/// Given the path to a source file containing a `mod` item, and the name of the module, attempts
/// to find the source file which contains that module. It does this by trying first to find a
/// file `$MODNAME.rs` in the same directory as `source_path`, and failing that will look for
/// `$MODNAME/mod.rs`. If either of those exises, the path to the file is returned, but no attempt
/// is made to determine if it's valid Rust code.
///
/// If it fails, returns a descriptive error
fn find_module(source_path: &Path, module_name: &str) -> Fallible<PathBuf> {
let mut path = source_path.to_owned();
//Pop the file name so we have just the directory path
path.pop();
path.push(format!("{}.rs", module_name));
if path.exists() {
return Ok(path);
}
path.pop();
path.push(format!("{}/mod.rs", module_name));
if path.exists() {
return Ok(path);
}
//Else, could not find the module's source code
bail!("Unable to locate source code for module '{}'", module_name);
}
/// Simple implementation of the `Visit` trait provided by `syn`, to traverse the AST of a single
/// source file, looking for tokens that indicate an external reference
struct Visitor {
deps: Vec<SourceDependency>,
}
impl Visitor {
fn new() -> Visitor {
Visitor { deps: vec![] }
}
}
impl<'ast> Visit<'ast> for Visitor {
fn visit_item_mod(&mut self, i: &'ast syn::ItemMod) {
//First call the default implementation.
syn::visit::visit_item_mod(self, i);
//Now look at this mod statement. If it has an implementation, then we're done. If not,
//if it looks something like:
//```
//mod foo;
//```
//
//Then it actually works a bit like a #include in C. Try to find the source file for that
//module, relative to the current source file, which should be the last element in the
//`paths` member.
if i.content == None {
let mut module_name = i.ident.to_string();
//Rust allows module names which are also Rust reserved words to be escaped with `r#`,
//for example:
//
//```
//mod r#static //this is in `static.rs` or `static/mod.rs`
//```
let module_name = if module_name.starts_with("r#") {
module_name.split_off(2)
} else {
module_name
};
self.deps.push(SourceDependency::Mod(module_name));
}
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::testdata::*;
use failure::Error;
use std::fs::File;
use std::io::Read;
fn parse(source_path: &Path) -> Fallible<syn::File> {
let mut file = File::open(source_path)?;
let mut src = String::new();
file.read_to_string(&mut src)?;
Ok(syn::parse_file(&src)?)
}
fn find_sources(entrypoint: &Path) -> (Vec<PathBuf>, Vec<(PathBuf, Error)>) {
let mut source_paths: Vec<PathBuf> = Vec::new();
let mut source_errors: Vec<(PathBuf, Error)> = Vec::new();
match parse(entrypoint) {
Ok(ast) => {
source_paths.push(entrypoint.to_owned());
let deps = get_dependencies(&ast);
for dep in deps {
match resolve_dependency(entrypoint, &dep) {
Ok(dep_path) => {
let (mut dep_paths, mut dep_errors) = find_sources(&dep_path);
source_paths.append(&mut dep_paths);
source_errors.append(&mut dep_errors);
}
Err(e) => source_errors.push((entrypoint.to_owned(), e)),
}
}
}
Err(e) => source_errors.push((entrypoint.to_owned(), e)),
}
(source_paths, source_errors)
}
#[test]
fn test_case() {
for case in TEST_CRATES.iter() {
for target in case.targets.iter() {
let entrypoint = case.root_directory.join(target.entrypoint);
let (paths, errors) = find_sources(&entrypoint);
let mut expected_paths = vec![entrypoint];
let mut additional_paths: Vec<_> = target
.additional_source_files
.iter()
.map(|p| case.root_directory.join(p))
.collect();
expected_paths.append(&mut additional_paths);
assert_eq!(expected_paths, paths);
//Make sure all expected errors were reported, and that no other, unexpected errors
//were
let unexpected_errors = errors
.iter()
.filter(|(file, error_msg)| {
//Look in the expected errors; was this one expected?
!target
.expected_errors
.iter()
.any(|(expected_file, expected_substring)| {
&case.root_directory.join(expected_file) == file
&& error_msg.to_string().contains(expected_substring)
})
})
.map(|(file, error_msg)| format!("{}: {}", file.to_str().unwrap(), error_msg))
.collect::<Vec<_>>();
assert_eq!(
Vec::<String>::new(),
unexpected_errors,
"Some unexpected errors were reported"
);
let missing_errors = target
.expected_errors
.iter()
.filter(|(expected_file, expected_substring)| {
!errors.iter().any(|(file, error_msg)| {
&case.root_directory.join(expected_file) == file
&& error_msg.to_string().contains(expected_substring)
})
})
.map(|(expected_file, expected_substring)| {
format!("{}: {}", expected_file, expected_substring)
})
.collect::<Vec<_>>();
assert_eq!(
Vec::<String>::new(),
missing_errors,
"Some expected errors were not reported"
);
}
}
}
}
================================================
FILE: tracers-codegen/src/error.rs
================================================
//! Defines an error type which can represent all the various kinds of failures the code gen
//! process can encounter. More specifically to this use case, the error type can also produce a
//! `TokenStream` which, when consumed by the `rustc` compiler, causes the compile to fail with a
//! compiler error with the text of whatever the error message was. That's how the proc macros
//! communicate failure details back to the compiler at compile time.
use darling::Error as DarlingError;
use failure::{Error, Fail};
use proc_macro2::Span;
use proc_macro2::TokenStream;
use quote::ToTokens;
use std::fmt;
use std::fmt::Display;
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
#[derive(Debug, Fail)]
pub enum TracersError {
InvalidProvider {
message: String,
#[fail(cause)]
syn_error: Error,
},
SynError {
message: String,
#[fail(cause)]
syn_error: Error,
},
DarlingError {
message: String,
darling_error: Arc<Mutex<DarlingError>>,
},
InvalidCallExpression {
message: String,
#[fail(cause)]
syn_error: Error,
},
OtherError {
message: String,
#[fail(cause)]
error: Error,
},
MissingCallInBuildRs,
BuildInfoReadError {
message: String,
build_info_path: String,
#[fail(cause)]
error: Error,
},
BuildInfoWriteError {
message: String,
build_info_path: String,
#[fail(cause)]
error: Error,
},
ProviderTraitNotProcessedError {
message: String,
trait_name: String,
#[fail(cause)]
error: Error,
},
CodeGenerationError {
message: String,
},
NativeCodeGenerationError {
message: String,
#[fail(cause)]
error: Error,
},
}
impl Display for TracersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
TracersError::InvalidProvider { message, .. } => write!(f, "{}", message),
TracersError::SynError { message, .. } => write!(f, "{}", message),
TracersError::DarlingError { message, .. } => write!(f, "{}", message),
TracersError::InvalidCallExpression { message, .. } => write!(f, "{}", message),
TracersError::OtherError { message, .. } => write!(f, "{}", message),
TracersError::MissingCallInBuildRs => write!(f, "Build environment is incomplete; make sure you are calling `tracers_build::build()` in your `build.rs` build script"),
TracersError::BuildInfoReadError { message, .. } => write!(f, "{}", message),
TracersError::BuildInfoWriteError { message, .. } => write!(f, "{}", message),
TracersError::ProviderTraitNotProcessedError { message,.. } => write!(f, "{}", message),
TracersError::CodeGenerationError { message } => write!(f, "Error generating probing code: {}", message),
TracersError::NativeCodeGenerationError { message, .. } => write!(f, "Error generating or compiling native C++ wrapper code: {}", message)
}
}
}
unsafe impl Send for TracersError {}
unsafe impl Sync for TracersError {}
impl PartialEq<TracersError> for TracersError {
fn eq(&self, other: &TracersError) -> bool {
//There are a lot of types that don't support equality. To keep it easy, just compare the
//display version
self.to_string() == other.to_string()
}
}
impl TracersError {
pub fn invalid_provider<T: ToTokens>(message: impl AsRef<str>, element: T) -> TracersError {
let message = format!(
"There's a problem with this provider trait: {}",
message.as_ref()
);
let e = Self::new_syn_error(&message, element);
TracersError::InvalidProvider {
message,
syn_error: e,
}
}
pub fn syn_error(message: impl AsRef<str>, e: syn::Error) -> TracersError {
// When this happens, it means we got a `syn::Error` back from the `syn` library when we
// asked it to parse a token stream. The message in this error will be something generic,
// where as our `message` will have important details that will help the user understand
// what went wrong. So we need to construct our own `syn::Error` which includes this
// context, while using the `span` from `e` so it is attached to the right part of the
// input code.
let message = format!("Parse error: {}\nDetails: {}", message.as_ref(), e);
let e = syn::Error::new(e.span(), &message);
let e = Self::wrap_syn_error(e);
TracersError::SynError {
message,
syn_error: e,
}
}
/// When we need to raise an error that is attached to a `syn` type (meaning the span of the
/// error will correctly be associated with that type), this method is used. There is no
/// actual `syn` error, we're just reporting a logic error of our own while processing some
/// `syn` types.
pub fn syn_like_error<T: ToTokens, U: Display>(message: U, tokens: T) -> TracersError {
let message = message.to_string();
Self::syn_error(&message, syn::Error::new_spanned(tokens, &message))
}
pub fn darling_error(e: DarlingError) -> TracersError {
let message = e.to_string();
TracersError::DarlingError {
message,
darling_error: Arc::new(Mutex::new(e)),
}
}
pub fn invalid_call_expression<T: ToTokens>(
message: impl AsRef<str>,
element: T,
) -> TracersError {
let message = format!("Invalid call expression: {}", message.as_ref());
let e = Self::new_syn_error(&message, element);
TracersError::InvalidCallExpression {
message,
syn_error: e,
}
}
pub fn other_error<D: Display + Send + Sync + 'static>(e: failure::Context<D>) -> TracersError {
TracersError::OtherError {
message: Self::fail_string(&e),
error: e.into(),
}
}
pub fn missing_call_in_build_rs() -> TracersError {
TracersError::MissingCallInBuildRs
}
pub fn build_info_read_error(build_info_path: PathBuf, e: Error) -> TracersError {
let message = format!("Unable to read build info from '{}'.\nAre you sure you're calling `tracers_build::build()` in your `build.rs`?\nError cause: {}",
build_info_path.display(),
Self::error_string(&e));
TracersError::BuildInfoReadError {
message,
build_info_path: build_info_path.display().to_string(),
error: e,
}
}
pub fn build_info_write_error(build_info_path: PathBuf, e: Error) -> TracersError {
let message = format!("Unable to write build info from '{}'.\nAre you sure you're calling `tracers_build::build()` in your `build.rs`?\nError cause: {}",
build_info_path.display(),
Self::error_string(&e));
TracersError::BuildInfoWriteError {
message,
build_info_path: build_info_path.display().to_string(),
error: e,
}
}
pub fn provider_trait_not_processed_error<T: AsRef<str>, E: Into<Error> + Display>(
trait_name: T,
e: E,
) -> TracersError {
TracersError::ProviderTraitNotProcessedError {
message: format!("The provider trait '{}' couldn't be processed by the code generator: {}\nCheck your build output for errors. Tracing will be disabled for this provider",
trait_name.as_ref(),
e),
trait_name: trait_name.as_ref().to_owned(),
error: e.into()
}
}
pub fn code_generation_error<S: AsRef<str>>(message: S) -> TracersError {
TracersError::CodeGenerationError {
message: message.as_ref().to_owned(),
}
}
pub fn native_code_generation_error<S: AsRef<str>, E: Into<Error> + Display>(
message: S,
e: E,
) -> TracersError {
TracersError::NativeCodeGenerationError {
message: format!("{}: {}", message.as_ref(), e),
error: e.into(),
}
}
/// Converts this error type into a `syn::Error`, preserving context from spans and elements if
/// any were given
pub fn into_syn_error(self) -> syn::Error {
match self {
TracersError::InvalidProvider { syn_error, .. } => Self::error_as_syn_error(syn_error),
TracersError::SynError { syn_error, .. } => Self::error_as_syn_error(syn_error),
TracersError::InvalidCallExpression { syn_error, .. } => {
Self::error_as_syn_error(syn_error)
}
others => syn::Error::new(Span::call_site(), others.to_string()),
}
}
/// Convert this error into a `TokenStream` such that when the compiler consumes the token
/// stream it will evaluate to a compile error, with the span corresponding to whatever element
/// was used to report the error. For those error types that don't have a corresponding
/// element, the call site of the macro will be used
pub fn into_compiler_error(self) -> TokenStream {
//Darling's error type already produces a token stream for errors with useful context into,
//so preserve that, otherwise build our own compiler error
if let TracersError::DarlingError { darling_error, .. } = self {
//Unwrap this error object from Arc and Mutex (it's not Send + Sync natively)
//and use the write_error() method to generate a helpful TokenStream
let lock =
Arc::try_unwrap(darling_error).expect("Somehow a lock is still held on this error");
let darling_error = lock
.into_inner()
.expect("The mutex can't possibly be locked");
darling_error.write_errors()
} else {
self.into_syn_error().to_compile_error()
}
}
fn new_syn_error<T: ToTokens, U: Display>(message: U, tokens: T) -> Error {
Self::wrap_syn_error(syn::Error::new_spanned(tokens, message))
}
fn wrap_syn_error(e: syn::Error) -> Error {
Self::wrap_error(e)
}
/// Given a `failure` `Error` type, tests to see if it wraps a real `syn::Error`, and if it
/// doesn't, creates a `syn::Error` with the same message
fn error_as_syn_error(e: Error) -> syn::Error {
e.downcast::<syn::Error>()
.unwrap_or_else(|e| syn::Error::new(Span::call_site(), e.to_string()))
}
fn wrap_error(e: impl std::error::Error + Sync + Send + 'static) -> Error {
e.into()
}
/// Builds an error string with all the relevant info from a `Fail` implementation
#[allow(clippy::redundant_closure)] //clippy's proposed alterstatic won't compile here
fn error_string(e: &Error) -> String {
let causes: Vec<_> = e.iter_chain().map(|c| c.to_string()).collect();
causes.join(": ")
}
#[allow(clippy::redundant_closure)] //clippy's proposed alterstatic won't compile here
fn fail_string(f: &dyn Fail) -> String {
let causes: Vec<_> = f.iter_chain().map(|c| c.to_string()).collect();
causes.join(": ")
}
}
/// Implement conversion from regular errors into a TracersError, but only if the error has been
/// given a context message using the `.context()` extension method provided by `failure`
impl<D: Display + Send + Sync + 'static> From<failure::Context<D>> for TracersError {
fn from(failure: failure::Context<D>) -> TracersError {
TracersError::other_error(failure)
}
}
pub type TracersResult<T> = std::result::Result<T, TracersError>;
================================================
FILE: tracers-codegen/src/gen/common/mod.rs
================================================
//! This module contains some code which is shared between the different code generation
//! implementations. It does not contain a working code generator implementation itself.
use crate::build_rs::BuildInfo;
use crate::spec::ProbeArgSpecification;
use crate::spec::ProbeSpecification;
use crate::spec::ProviderInitSpecification;
use crate::spec::ProviderSpecification;
use crate::TracersResult;
use heck::SnakeCase;
use proc_macro2::TokenStream;
use quote::ToTokens;
use quote::{quote, quote_spanned};
use syn::spanned::Spanned;
/// Base trait for the provider generators. Contains logic that is common to all of the
/// generators
pub(super) trait ProviderTraitGeneratorBase {
fn spec(&self) -> &ProviderSpecification;
fn build_info(&self) -> &BuildInfo;
/// Generates the an additional doc comment for the generated provider trait/struct/whatever, which
/// provides some helpful information about how to use that provider with the various tracing
/// platforms. This way callers can simply generate docs on their own crates and get help with
/// tracing.
fn generate_trait_comment(&self) -> TokenStream {
let comment = format!(
r###"
# Probing
This trait is translated at compile-time by `tracers` into a platform-specific tracing
provider, which allows very high-performance and low-overhead tracing of the probes it
fires.
The exact details of how to use interact with the probes depends on the underlying
probing implementation.
## SystemTap/USDT (Linux x64)
This trait corresponds to a SystemTap/USDT provider named `{provider_name}`,
## Other platforms
TODO: No other platforms supported yet
"###,
provider_name = self.spec().name()
);
generate_multiline_comments(&comment)
}
/// Generates the declaration (but *NOT* the *implementation*) of the `__try_init_provider` method.
/// This includes a detailed doc comment. Each generator must implement this method, but this
/// generates the declaration, looking something like this:
///
/// ```no_execute
/// #[allow(dead_code)]
/// #vis fn __try_init_provider() -> Result<&'static str, &'static str>
/// ```
///
/// The actual generator should insert this token stream in the generated trait/struct, followed by
/// an implementation contained in `{}` chars
fn generate_try_init_decl(&self) -> TokenStream {
let vis = &self.spec().item_trait().vis;
quote! {
/// **NOTE**: This function was generated by the `tracers` macro
///
/// Initializes the provider, if it isn't already initialized, and if initialization
/// failed returns the error.
///
/// # Usage
///
/// Initializing the provider is not required. By default, each provider will lazily
/// initialize the first time a probe is fired. Explicit initialization can be useful
/// because it ensures that all of a provider's probes are registered and visible to
/// the platform-specific tracing tools, like `bpftrace` or `tplist` on Linux.
///
/// It's ok to initialize a provider more than once; init operations are idempotent and
/// if repeated will not do anything
///
/// # Returns
///
/// The return value is a `Result<&'static str, &'static str>`. The `Ok` value is a string
/// with some information about the provider. The `Err` value is an error message
/// indicating the provider failed to initialize, and why.
///
/// Note that whether or not the provider initialization failed, the `probe!` macros never
/// return an error or panic. They will detect the initialization failed and do nothing,
/// not even evaluate the arguments to the probe.
///
/// # Caution
///
/// Callers should not call this method directly. Instead use the provided
/// `init_provider!` macro. This will correctly elide the call when probing is
/// compile-time disabled. When `tracers` is compiled with tracing disabled, this function
/// will not be generated so any code that assumes its presence will break;
///
/// # Example
///
/// ```
/// use tracers_macros::{init_provider, tracer, probe};
///
/// #[tracer]
/// trait MyProbes {
/// fn probe0();
/// }
///
/// if let Err(err) = init_provider!(MyProbes) {
/// eprintln!("Probe provider failed to initialize: {}", err);
/// }
///
/// //Note that even if the provider fails to initialize, firing probes will never fail
/// //or panic...
///
/// println!("Firing anyway...");
/// probe!(MyProbes::probe0());
/// ```
#[allow(dead_code)]
#vis fn __try_init_provider() -> ::core::result::Result<&'static str, &'static str>
}
}
/// Returns the name of the module in which most of the implementation code for this trait will be
/// located.
fn get_provider_impl_mod_name(&self) -> syn::Ident {
let snake_case_name = get_provider_impl_mod_name(&self.spec().item_trait().ident);
syn::Ident::new(&snake_case_name, self.spec().item_trait().ident.span())
}
/// The name of the struct type within the impl module which represents the provider, eg `MyProbesProviderImpl`.
/// Note that this is not the same as the struct which we generate which has the same name as the
/// trait and implements its methods.
fn get_provider_impl_struct_type_name(&self) -> syn::Ident {
crate::syn_helpers::add_suffix_to_ident(&self.spec().item_trait().ident, "ProviderImpl")
}
}
/// Base trait for the provider generators. Contains logic that is common to all of the
/// generators
pub(super) trait ProbeGeneratorBase {
fn spec(&self) -> &ProbeSpecification;
/// Generates the `#[deprecated...]` attribute which triggers a warning if anyone tries to call the
/// probe method directly, not through the `probe!` attribute
fn generate_probe_deprecation_attribute(
&self,
provider: &ProviderSpecification,
) -> TokenStream {
let deprecation_message = format!( "Probe methods should not be called directly. Use the `probe!` macro, e.g. `probe!({}::{}(...))`",
provider.item_trait().ident,
self.spec().method_name);
let span = self.spec().method_name.span();
quote_spanned! {span=>
#[deprecated(note = #deprecation_message)]
}
}
/// Generates a doc comment to attach to the probe's method. This includes additional information
/// about how to work with this probe on various platforms.
fn generate_probe_doc_comment(&self, provider: &ProviderSpecification) -> TokenStream {
let probe_comment = format!(r###"
# Probing
This method is translated at compile-time by `tracers` into a platform-specific tracing
probe, which allows very high-performance and low-overhead tracing.
## How to fire probe
To fire this probe, don't call this method directly. Instead, use the `probe!` macro, for example:
```ignore
// If the probe is enabled, fires the probe. If the probe isn't enabled, or if provider
// initialization failed for some reason, does not fire the probe, and does NOT evaluate the
// arguments to the probe.
probe!({trait_name}::{probe_name}(...));
```
The exact details of how to interact with the probes depends on the underlying
probing implementation.
## SystemTap/USDT (Linux x64)
To trace the firing of this probe, use `bpftrace`, e.g.:
```text
sudo bpftrace -p ${{PID}} -e 'usdt::{provider}:{probe_name} {{ printf("Hello from {probe_name}\n"); }}'
```
where `${{PID}}` should be the actual process ID of the process you are tracing.
## Other platforms
TODO: No other platforms supported yet
"###,
trait_name = &provider.item_trait().ident,
probe_name = &self.spec().name,
provider = provider.name(),
);
generate_multiline_comments(&probe_comment)
}
/// Gets all of the lifetime parameters for all of the reference args for this probe, in a
/// `Vec` for convenient post-processing.
///
/// For example:
///
/// ```noexecute
/// fn probe(arg0: &str, arg1: usize, arg2: Option<Result<(), &String>>;
///
/// // results in vec!['probe_arg0_1, 'probe_arg2, _1]
/// ```
fn args_lifetime_parameters(&self) -> Vec<syn::Lifetime> {
self.spec()
.args
.iter()
.map(ProbeArgSpecification::lifetimes)
.flatten()
.collect::<Vec<syn::Lifetime>>()
}
/// Build a tuple value expression, consisting of the names of the probe arguments in a tuple.
/// For example:
///
/// ```noexecute
/// fn probe(arg0: &str, arg1: usize); //results in tuple: (arg0, arg1,)
/// ```
fn args_as_tuple_value(&self) -> TokenStream {
let names = self.spec().args.iter().map(ProbeArgSpecification::ident);
generate_tuple(names)
}
/// Build a tuple type expression whose elements correspond to the arguments of this probe.
/// This includes only the type of each argument, and has no explicit lifetimes specified. For
/// that there is `args_as_tuple_type_with_lifetimes`
fn args_as_tuple_type_without_lifetimes(&self) -> TokenStream {
//When the probe spec is constructed lifetime parameters are added, so to construct a tuple
//type without them they need to be stripped
let args = self.spec().args.iter().map(ProbeArgSpecification::syn_typ);
generate_tuple(args)
}
/// Like the method above constructs a tuple type corresponding to the types of the arguments of this probe.
/// Unlike the above method, this tuple type is also annotated with explicit lifetime
/// parameters for all reference types in the tuple.
fn args_as_tuple_type_with_lifetimes(&self) -> TokenStream {
// same as the above method, but use the version with lifetime annotations
let types = self
.spec()
.args
.iter()
.map(ProbeArgSpecification::syn_typ_with_lifetimes);
generate_tuple(types)
}
}
/// Returns the name of the module in which most of the implementation code for this trait will be
/// located.
pub(super) fn get_provider_impl_mod_name(trait_ident: &syn::Ident) -> String {
format!("__{}", format!("{}Provider", trait_ident).to_snake_case())
}
/// Given an iterable sequence of `TokenStream`s, produces a new `TokenStream` which will be a
/// tuple expression with each element of the tuple corresponding to a stream in the iterator.
///
/// This handles the special-case syntax whereby an empty iterator is `()` but all others have a
/// trailing comma
pub(super) fn generate_tuple<T: ToTokens, I: IntoIterator<Item = T>>(elements: I) -> TokenStream {
let mut elements = elements.into_iter().peekable();
//If this is empty, the tuple expression is `()`, but if it's not then there should be a
//trailing comma at the end
if elements.peek().is_none() {
quote! { () }
} else {
quote! { ( #(#elements),*, )}
}
}
/// Generates the standard provider init call. Some implementations may use a different one but
/// this is the typical impl.
pub(super) fn generate_init_provider(
init: ProviderInitSpecification,
) -> TracersResult<TokenStream> {
//This couldn't be simpler. We must assume the caller provided a valid provider trait. If
//they didn't this will fail at compile time in a fairly obvious way.
//
//So we just generate code to call the init function that the provider trait generator will
//have already generated on the trait itself.
let provider = init.provider;
let span = provider.span();
Ok(quote_spanned! {span=>
#provider::__try_init_provider()
})
}
/// When generating a comment with `#[doc]` if the string is multi-lined then `quote_spanned` seems
/// to get confused and puts the rest of the lines of the string in a separate token tree.
/// This method simply takes a multi-line string literal, breaks it up into separate lines, and
/// generates one `#[doc...]` comment per line
fn generate_multiline_comments(comment: &str) -> TokenStream {
let lines = comment.lines().map(|line| {
let with_leading_space = format!(" {}", line);
quote! {
#[doc = #with_leading_space]
}
});
quote! {
#(#lines)*
}
}
================================================
FILE: tracers-codegen/src/gen/dynamic/mod.rs
================================================
//! The `dynamic` generator generates probing code which uses the runtime tracing API in
//! `tracers-core`. Currently there is only one real implementation of that API, which uses
//! `libstapsdt` underneath to support creating SystemTap user-mode probes on 64-bit x86 Linux.
//! However other implementations using DTrace's equivalent library are also possible.
//!
//! This "dynamic" style was the first tracing mode supported in this library, but if I were to
//! write this crate over again I would never implement this mode. The `static` style of probing
//! does more work at compile time and fits much better in the SystemTap/DTrace/ETW style of
//! tracing. However, this remains in case a use for it emerges, perhaps on another platform with
//! more intrinsic support for dynamic style tracing.
use super::NativeLib;
use crate::build_rs::BuildInfo;
use crate::gen::common;
use crate::spec::ProbeCallSpecification;
use crate::spec::ProviderInitSpecification;
use crate::spec::ProviderSpecification;
use crate::{gen::CodeGenerator, TracersResult};
use proc_macro2::TokenStream;
use std::io::Write;
use std::path::{Path, PathBuf};
mod probe_call;
mod provider_trait;
pub(crate) struct DynamicGenerator {
build_info: BuildInfo,
}
impl DynamicGenerator {
pub fn new(build_info: BuildInfo) -> DynamicGenerator {
DynamicGenerator { build_info }
}
}
impl CodeGenerator for DynamicGenerator {
fn handle_provider_trait(&self, provider: ProviderSpecification) -> TracersResult<TokenStream> {
let generator = provider_trait::ProviderTraitGenerator::new(&self.build_info, provider);
generator.generate()
}
fn handle_probe_call(&self, call: ProbeCallSpecification) -> TracersResult<TokenStream> {
probe_call::generate_probe_call(call)
}
fn handle_init_provider(&self, init: ProviderInitSpecification) -> TracersResult<TokenStream> {
common::generate_init_provider(init)
}
fn generate_native_code(
&self,
stdout: &mut dyn Write,
_manifest_dir: &Path,
_out_dir: &Path,
_package_name: &str,
_targets: Vec<PathBuf>,
) -> Vec<NativeLib> {
// The nice thing about this implementation is that no build-time code generation is
// required
let _ = writeln!(
stdout,
"dynamic generator doesn't require any build.rs code generation"
);
vec![]
}
}
================================================
FILE: tracers-codegen/src/gen/dynamic/probe_call.rs
================================================
//! This module generates the code for a call to a probe implemented with the `libstapsdt` library.
//! It's rather simple, because it assumes the Rust bindings on the `libstapsdt` API are already a
//! dependency and exposed via the `SystemTracer` type alias.
use crate::spec::ProbeCallSpecification;
use crate::TracersResult;
use proc_macro2::TokenStream;
use quote::{quote, quote_spanned};
use syn::spanned::Spanned;
/// Translates what looks to be an explicit call to the associated function corresponding to a
/// probe on a provider trait, into something which at runtime will most efficiently attempt to
/// access the global static instance of the probe and, if it's enabled, evaluate the args and fire
/// the probe.
///
/// It translates something like this:
///
/// ```noexecute
/// probe!(MyProvider::myprobe(1, 5, "this is a string", compute_something()));
/// ```
///
/// into:
///
/// ```noexecute
/// {
/// if let Some(probe) = MyProvider::get_myprobe_probe() {
/// if probe.is_enabled() {
/// probe.fire((1, 5, "this is a string", compute_something(),)));
/// }
/// }
/// }
/// ```
///
/// In particular, note that the probe's parameters are not evaluated unless the provider
/// initialized successfully and the probe is enabled.
pub(super) fn generate_probe_call(call: ProbeCallSpecification) -> TracersResult<TokenStream> {
match call {
ProbeCallSpecification::FireOnly(details) => {
//Easy one. This call is already set up like a Rust method call on the probe method of
//the provider trait. Just need to rewrite the name of the function from `(probename)`
//to `get_(probename)_probe` and then make the call
let probe_func_name = syn::Ident::new(
&format!("get_{}_probe", details.probe.ident),
details.probe.ident.span(),
);
let span = details.call.span();
let provider = details.provider;
//the `fire` method on the probe object takes a single argument, which is a tuple of
//all of the probe args. Build that here, though note there's a different syntax for
//an empty tuple
let args = if details.args.is_empty() {
quote! { () }
} else {
let args = details.args;
quote! { (#(#args),*,) }
};
Ok(quote_spanned! {span=>
{
if let Some(__tracers_probe) = #provider::#probe_func_name() {
if __tracers_probe.is_enabled() {
__tracers_probe.fire(#args);
}
}
}
})
}
ProbeCallSpecification::FireWithCode { .. } => unimplemented!(),
}
}
================================================
FILE: tracers-codegen/src/gen/dynamic/provider_trait.rs
================================================
//!Code in this module processes the provider trait decorated with the `tracers` attribute, and
//!replaces it with an implementation using libstapsdt.
use crate::build_rs::BuildInfo;
use crate::gen::common::{ProbeGeneratorBase, ProviderTraitGeneratorBase};
use crate::spec::ProbeSpecification;
use crate::spec::ProviderSpecification;
use crate::syn_helpers;
use crate::TracersResult;
use heck::ShoutySnakeCase;
use proc_macro2::TokenStream;
use quote::{quote, quote_spanned};
use syn::parse_quote;
use syn::spanned::Spanned;
pub(super) struct ProviderTraitGenerator<'bi> {
build_info: &'bi BuildInfo,
spec: ProviderSpecification,
probes: Vec<ProbeGenerator>,
}
impl<'bi> ProviderTraitGeneratorBase for ProviderTraitGenerator<'bi> {
fn spec(&self) -> &ProviderSpecification {
&self.spec
}
fn build_info(&self) -> &BuildInfo {
self.build_info
}
}
impl<'bi> ProviderTraitGenerator<'bi> {
pub fn new(
build_info: &'bi BuildInfo,
spec: ProviderSpecification,
) -> ProviderTraitGenerator<'bi> {
//This implementation is specific to dynamic tracing
assert!(build_info.implementation.is_dynamic());
//Consume this provider spec and separate out the probe specs, each of which we want to
//wrap in our own ProbeGenerator
let (spec, probes) = spec.separate_probes();
let probes: Vec<_> = probes.into_iter().map(ProbeGenerator::new).collect();
ProviderTraitGenerator {
build_info,
spec,
probes,
}
}
pub fn generate(&self) -> TracersResult<TokenStream> {
// Re-generate this trait as a struct with our probing implementation in it
let tracer_struct = self.generate_tracer_struct()?;
// Generate code for a struct and some `OnceCell` statics to hold the instance of the provider
// and individual probe wrappers
let impl_mod = self.generate_impl_mod();
let span = self.spec.item_trait().span();
Ok(quote_spanned! {span=>
#tracer_struct
#impl_mod
})
}
/// A provider is described by the user as a `trait`, with methods corresponding to probes.
/// However it's actually implemented as a `struct` with no member fields, with static methods
/// implementing the probes. Thus, given as input the `trait`, we produce a `struct` of the same
/// name whose implementation actually performs the firing of the probes.
fn generate_tracer_struct(&self) -> TracersResult<TokenStream> {
// From the probe specifications, generate the corresponding methods that will be on the probe
// struct.
let mut probe_methods: Vec<TokenStream> = Vec::new();
let mod_name = self.get_provider_impl_mod_name();
let struct_type_name = self.get_provider_impl_struct_type_name();
let struct_type_path: syn::Path = parse_quote! { #mod_name::#struct_type_name };
for probe in self.probes.iter() {
probe_methods.push(probe.generate_trait_methods(self, &struct_type_path)?);
}
// Re-generate the trait method that we took as input, with the modifications to support
// probing
// This includes constructing documentation for this trait, using whatever doc strings are already applied by
// the user, plus a section of our own that has information about the provider and how it
// translates into the various implementations.
//
// Hence, the rather awkward `#[doc...]` bits
let attrs = &self.spec.item_trait().attrs;
let span = self.spec.item_trait().span();
let ident = &self.spec.item_trait().ident;
let vis = &self.spec.item_trait().vis;
let mod_name = self.get_provider_impl_mod_name();
let struct_type_name = self.get_provider_impl_struct_type_name();
let trait_doc_comment = self.generate_trait_comment();
let try_init_decl = self.generate_try_init_decl();
//the __try_init_provider returns a Result. In this no-op implementation, we'll hard-code
//a successful result, with a string containing some metadata about the generated provider
let provider_name = self.spec.name();
let implementation = format!(
"{}/{}",
self.build_info.implementation.tracing_type().as_ref(),
self.build_info.implementation.as_ref()
);
let version = env!("CARGO_PKG_VERSION");
let result = quote_spanned! {span=>
#(#attrs)*
#trait_doc_comment
#vis struct #ident;
impl #ident {
#(#probe_methods)*
#try_init_decl {
let result = #mod_name::#struct_type_name::get();
// On success, translate from the probe struct to the informational message
result.map(|_| {
concat!(#provider_name, "::", #implementation, "::", #version)
})
}
}
};
Ok(result)
}
/// The implementation of the probing logic is complex enough that it involves the declaration of a
/// few variables and one new struct type. All of this is contained within a module, to avoid the
/// possibility of collissions with other code. This method generates that module and all its
/// contents.
///
/// The contents are, briefly:
/// * The module itself, named after the trait
/// * A declaration of a `struct` which will hold references to all of the probes
/// * Multiple static `OnceCell` variables which hold the underlying provider instance as well as
/// the instance of the `struct` which holds references to all of the probes
fn generate_impl_mod(&self) -> TokenStream {
let mod_name = self.get_provider_impl_mod_name();
let struct_type_name = self.get_provider_impl_struct_type_name();
let struct_var_name = self.get_provider_impl_struct_var_name();
let struct_type_params = self.generate_provider_struct_type_params();
let instance_var_name = self.get_provider_instance_var_name();
let define_provider_call = self.generate_define_provider_call();
let provider_var_name = syn::Ident::new("p", self.spec.item_trait().span());
let struct_members: Vec<_> = self
.probes
.iter()
.map(ProbeGenerator::generate_struct_member_declaration)
.collect();
let struct_initializers: Vec<_> = self
.probes
.iter()
.map(|probe| probe.generate_struct_member_initialization(&provider_var_name))
.collect();
let span = self.spec.item_trait().span();
quote_spanned! {span=>
mod #mod_name {
use ::tracers::runtime::failure::{format_err, Fallible};
use ::tracers::runtime::dynamic::once_cell::sync::OnceCell;
use ::tracers::runtime::dynamic::{SystemTracer,SystemProvider,ProviderBuilder,Tracer};
// Need the `Provider` trait in scope so we can access its methods on its
// implementors
use ::tracers::runtime::dynamic::Provider as _;
use ::core::result::Result;
#[allow(dead_code)]
pub(super) struct #struct_type_name<#struct_type_params> {
#(pub #struct_members),*
}
unsafe impl<#struct_type_params> Send for #struct_type_name<#struct_type_params> {}
unsafe impl<#struct_type_params> Sync for #struct_type_name <#struct_type_params>{}
static #instance_var_name: OnceCell<Fallible<SystemProvider>> = OnceCell::new();
static #struct_var_name: OnceCell<Result<#struct_type_name, String>> = OnceCell::new();
static IMPL_OPT: OnceCell<Result<&'static #struct_type_name, &'static str>> = OnceCell::new();
impl<#struct_type_params> #struct_type_name<#struct_type_params> {
#[allow(dead_code)]
pub(super) fn get() -> Result<&'static #struct_type_name<#struct_type_params>, &'static str> {
//let imp: &'static Result<&'static #struct_type_name, &'static str> = IMPL_OPT.get_or_init(|| {
let imp: &'static Result<_,_> = IMPL_OPT.get_or_init(|| {
// The reason for this seemingly-excessive nesting is that it's possible for
// both the creation of `SystemProvider` or the subsequent initialization of
// #struct_type_name to fail with different and also relevant errors. By
// separting them this way we're able to preserve the details about any init
// failures that happen, while at runtime when firing probes it's a simple
// call of a method on an `Option<T>`. I don't have any data to back this
// up but I suspect that allows for better optimizations, since we know an
// `Option<&T>` is implemented as a simple pointer where `None` is `NULL`.
let imp: &Result<#struct_type_name<#struct_type_params>, String> = #struct_var_name.get_or_init(|| {
// Initialzie the `SystemProvider`, capturing any initialization errors
let #provider_var_name: &Fallible<SystemProvider> = #instance_var_name.get_or_init(|| {
#define_provider_call
});
// Transform this #provider_var_name into an owned `Fallible` containing
// references to `T` or `E`, since there's not much useful you can do
// with just a `&Result`.
match #provider_var_name.as_ref() {
Err(e) => Err(format!("Provider initialization failed: {}", e)),
Ok(#provider_var_name) => {
// Proceed to create the struct containing each of the probes'
// `ProviderProbe` instances
Ok(
#struct_type_name{
#(#struct_initializers,)*
}
)
}
}
});
//Convert this &Fallible<..> into an Result<&T, &'static str>
imp.as_ref().map_err(|e| e.as_ref())
});
//Copy this `&Result<&T, &String>` to a new `Result<&T, &str>`. Since that should be
//implemented as just a pointer, this should be effectively free
//*imp
imp.map_err(|e| e.as_ref())
}
}
}
}
}
/// A `Provider` is built by calling `define_provider` on a `Tracer` implementation.
/// `define_provider` takes a closure and passes a `ProviderBuilder` parameter to that closure.
/// This method generates the call to `SystemTracer::define_provider`, and includes code to add
/// each of the probes to the provider
fn generate_define_provider_call(&self) -> TokenStream {
let builder = syn::Ident::new("builder", self.spec.item_trait().ident.span());
let add_probe_calls: Vec<TokenStream> = self
.probes
.iter()
.map(|probe| probe.generate_add_probe_call(&builder))
.collect();
let provider_name = self.spec.name();
let span = self.spec.item_trait().span();
quote_spanned! {span=>
// The provider name must be chosen carefully. As of this writing (2019-04) the `bpftrace`
// and `bcc` tools have, shall we say, "evolving" support for USDT. As of now, with the
// latest git version of `bpftrace`, the provider name can't have dots or colons. For now,
// then, the provider name is just the name of the provider trait, converted into
// snake_case for consistency with USDT naming conventions. If two modules in the same
// process have the same provider name, they will conflict and some unspecified `bad
// things` will happen.
let provider_name = #provider_name;
SystemTracer::define_provider(&provider_name, |mut #builder| {
#(#add_probe_calls)*
Ok(builder)
})
}
}
/// The provider struct we declare to hold the probe objects needs to take a lot of type
/// parameters. One type, 'a, which corresponds to the lifetime parameter of the underling
/// `ProviderProbe`s, and also one lifetime parameter for every reference argument of every probe
/// method.
///
/// The return value of this is a token stream consisting of all of the types, but not including
/// the angle brackets.
fn generate_provider_struct_type_params(&self) -> TokenStream {
// Make a list of all of the reference param lifetimes of all the probes
let probe_lifetimes: Vec<syn::Lifetime> = self
.probes
.iter()
.map(ProbeGenerator::args_lifetime_parameters)
.flatten()
.collect();
//The struct simply takes all of these lifetimes plus 'a
quote! {
'a, #(#probe_lifetimes),*
}
}
/// The name of the static variable which contains the singleton instance of the provider struct,
/// eg MYPROBESPROVIDERIMPL
fn get_provider_impl_struct_var_name(&self) -> syn::Ident {
syn::Ident::new(
&format!("{}ProviderImpl", self.spec.item_trait().ident).to_shouty_snake_case(),
self.spec.item_trait().span(),
)
}
/// The name of the static variable which contains the singleton instance of the underlying tracing
/// system's `Provider` instance, eg MYPROBESPROVIDER
fn get_provider_instance_var_name(&self) -> syn::Ident {
syn::Ident::new(
&format!("{}Provider", self.spec.item_trait().ident).to_shouty_snake_case(),
self.spec.item_trait().span(),
)
}
}
pub(super) struct ProbeGenerator {
spec: ProbeSpecification,
}
impl ProbeGeneratorBase for ProbeGenerator {
fn spec(&self) -> &ProbeSpecification {
&self.spec
}
}
impl ProbeGenerator {
pub fn new(spec: ProbeSpecification) -> ProbeGenerator {
ProbeGenerator { spec }
}
/// The name of the variable in the implementation struct which will hold this particular
/// probe's `ProviderProbe` wrapper object
pub(crate) fn probe_var_name(&self) -> &syn::Ident {
&self.spec.method_name
}
/// For each probe the user defines on the trait, we will generate multiple implementation
/// methods:
///
/// * `(probe_name)` - This is the same name as the method the user declared. It takes the same
/// arguments the user specified, and when called it checks to see if the probe is enabled and
/// if so fires the probe. This is implemented as a normal Rust function call, so the
/// arguments to the probe function are evaluated unconditionally, whether the probe is enabled
/// or not.
/// * `(probe_name)_is_enabled` - This takes no args and returns a `bool` indicating if the
/// probe is enabled or not. Most situations won't require this method, but in some rare cases
/// where some specific operation is conditional upon the enabling of a specific probe, this is
/// available.
/// * `if_(probe_name)_enabled` - This is a more complex version of `(probe_name)_is_enabled`
/// which takes as an argument a `FnOnce` closure, which itself is passed a `FnOnce` closure
/// which when called will fire the probe. If the probe is not enabled, this closure never
/// gets called. Thus, in this way callers can implement potentially expensive logic to
/// prepare information for a probe, and only run this code when the probe is activated.
pub fn generate_trait_methods(
&self,
provider: &ProviderTraitGenerator,
struct_type_path: &syn::Path,
) -> TracersResult<TokenStream> {
let vis = &self.spec.vis;
//The original method will be implemented as a call to the impl method. It's only purpose
//is to ensure the user can call the original method and get our warning reminding them ot
//use the `probe!` macro instead. Otherwise it would be confusing to not be able to call a
//method they think should exist on a trait they themselves defined, even if doing so is
//not the intended use of this crate.
let original_method = self.spec.original_method.sig.clone();
//Generate an _enabled method which tests if this probe is enabled at runtime
let mut enabled_method = original_method.clone();
enabled_method.ident = syn_helpers::add_suffix_to_ident(&enabled_method.ident, "_enabled");
enabled_method.inputs = syn::punctuated::Punctuated::new();
enabled_method.output = syn::ReturnType::Default;
//Generate an get_(probe)_probe method which returns the raw Option<ProviderProbe>
let mut probe_method = original_method.clone();
probe_method.ident = syn::Ident::new(
&format!("get_{}_probe", probe_method.ident),
probe_method.ident.span(),
);
probe_method.inputs = syn::punctuated::Punctuated::new();
probe_method.output = syn::ReturnType::Default;
let probe_method_ret_type = self.generate_provider_probe_type();
let a_lifetime = syn::Lifetime::new("'a", self.spec.span);
probe_method
.generics
.params
.push(syn::GenericParam::Lifetime(syn::LifetimeDef::new(
a_lifetime,
)));
for param in self.args_lifetime_parameters().iter() {
probe_method
.generics
.params
.push(syn::GenericParam::Lifetime(syn::LifetimeDef::new(
param.clone(),
)))
}
//Generate an _impl method that actually fires the probe when called
let mut impl_method = original_method.clone();
impl_method.ident = syn_helpers::add_suffix_to_ident(&impl_method.ident, "_impl");
//Generate the body of the original method, simply passing its arguments directly to the
//impl method
let probe_args_tuple = self.args_as_tuple_value();
//Keep the original probe method, but mark it deprecated with a helpful message so that if the
//user calls the probe method directly they will at least be reminded that they should use the
//macro instead.
let probe_ident = &self.spec.method_name;
let deprecation_attribute = self.generate_probe_deprecation_attribute(&provider.spec);
//Keep any attributes that were on the original method, and add `doc` attributes at the end
//to provide some more information about the generated probe mechanics
let attrs = &self.spec.original_method.attrs;
let probe_doc_comment = self.generate_probe_doc_comment(&provider.spec);
// Note that we don't put an #[allow(dead_code)] attribute on the original method, because
// the user declared that method. If it's not being used, let the compiler warn them about
// it just like it would any other unused method. The methods we generate, however, won't
// be directly visible to the user and thus should not cause a warning if left un-called
let span = original_method.span();
Ok(quote_spanned! {span=>
#(#attrs)*
#probe_doc_comment
#deprecation_attribute
#[allow(dead_code)]
#vis #original_method {
if let Ok(probes) = #struct_type_path::get() {
if probes.#probe_ident.is_enabled() {
probes.#probe_ident.fire(#probe_args_tuple)
}
};
}
#[allow(dead_code)]
#[doc(hidden)]
#vis #enabled_method -> bool {
if let Ok(probes) = #struct_type_path::get() {
probes.#probe_ident.is_enabled()
} else {
false
}
}
#[doc(hidden)]
#vis #probe_method -> Option<&'static #probe_method_ret_type> {
#struct_type_path::get().ok().map(|probes| &probes.#probe_ident)
}
})
}
/// When building a provider, individual probes are added by calling `add_probe` on the
/// `ProviderBuilder` implementation. This method generates that call for this probe. In this
/// usage the lifetime parameters are not needed.
pub(crate) fn generate_add_probe_call(&self, builder: &syn::Ident) -> TokenStream {
//The `add_probe` method takes one type parameter, which should be the tuple form of the
//arguments for this probe.
let args_type = self.args_as_tuple_type_with_lifetimes();
let probe_name = &self.spec.name;
let span = self.spec.original_method.span();
quote_spanned! {span=>
#builder.add_probe::<#args_type>(#probe_name)
.map_err(|e| format_err!(concat!("Error adding probe '", #probe_name, "': {}"), e))?;
}
}
/// Each probe has a corresponding field in the struct that we build for the provider. That
/// field is an instance of `ProviderProbe` which is a type-safe wrapper around the underlying
/// untyped implementation. Because it's type safe it must necessarily have type parameters
/// corresponding to the arguments to the probe. Thus its declaration gets a bit complicated.
///
/// Further complicating matters is that the lifetime elision that makes it so easy to declare
/// functions with reference args isn't available here, so every reference parameter the probe
/// takes needs to have a corresponding lifetime. This gets messy, as you'll see.
pub(crate) fn generate_provider_probe_type(&self) -> TokenStream {
let arg_tuple = self.args_as_tuple_type_with_lifetimes();
//In addition to the lifetime params for any ref args, all `ProviderProbe`s have a lifetime
//param 'a which corresponds to the lifetime of the underlying `UnsafeProviderProbeImpl`
//which they wrap. That is the same for all probes, so we just hard-code it as 'a
let a_lifetime = syn::Lifetime::new("'a", self.spec.span);
let span = self.spec.span;
quote_spanned! {span=>
::tracers::runtime::dynamic::ProviderProbe<#a_lifetime, ::tracers::runtime::dynamic::SystemProbe, #arg_tuple>
}
}
/// Generates the declaration of the member field within the provider implementation struct
/// that holds the `ProviderProbe` instance for this probe. It's a complex declaration because
/// it must include lifetime parameters for all of the reference types used by any of this
/// probe's arguments
pub(crate) fn generate_struct_member_declaration(&self) -> TokenStream {
let name = self.probe_var_name();
let typ = self.generate_provider_probe_type();
let span = self.spec.span;
quote_spanned! {span=>
#name: #typ
}
}
/// When we create a new instance of the struct which represents the provider and holds the
/// `ProviderProbe` objects for all of the probes, each of those members needs to be
/// initialized as part of the initialization expression for the struct. This method generates
/// the initialization expression for just this probe.
///
/// For the whole struct it would look something like:
///
/// ```noexecute
/// FooProviderImpl{
/// probe1: provider.probe::<(i32,)>("probe1")?,
/// probe2: provider.probe::<(&str,&str,)>("probe2")?,
/// ...
/// }
/// ```
///
/// This method generates just the line corresponding to this probe, without a trailing comma.
pub(crate) fn generate_struct_member_initialization(
&self,
provider: &syn::Ident,
) -> TokenStream {
let name_literal = &self.spec.name;
let name_ident = &self.spec.method_name;
let args_tuple = self.args_as_tuple_type_without_lifetimes();
let span = self.spec.span;
quote_spanned! {span=>
#name_ident: #provider.get_probe::<#args_tuple>(#name_literal)
.map_err(|e| format!(concat!("Error getting probe '", #name_literal, "': {}"), e))?
}
}
}
/// It's quite difficult to meaningfully test code generators that use the `quote` crate. These
/// tests exercise the code with various test cases, and verify that the generator doesn't fail or
/// panic. But they do not verify that the generated code will compile.
///
/// The integration tests and examples in the `tracers` parent crate do that.
#[cfg(test)]
mod test {
use super::*;
use crate::testdata;
use crate::TracingImplementation;
#[test]
fn generate_works_on_valid_traits() {
for test_case in testdata::get_test_provider_traits(|c: &testdata::TestProviderTrait| {
c.expected_error.is_none()
})
.into_iter()
{
for implementation in vec![
TracingImplementation::DynamicNoOp,
TracingImplementation::DynamicStap,
]
.into_iter()
{
let (attr, item_trait) = test_case.get_attr_and_item_trait();
let spec =
ProviderSpecification::from_trait(testdata::TEST_CRATE_NAME, attr, item_trait)
.unwrap_or_else(|_| {
panic!(format!(
"Failed to create specification from test trait '{}'",
test_case.description
))
});
let build_info =
BuildInfo::new(testdata::TEST_CRATE_NAME.to_owned(), implementation);
let generator = ProviderTraitGenerator::new(&build_info, spec);
generator.generate().unwrap_or_else(|_| {
panic!(format!(
"Failed to generate test trait '{}'",
test_case.description
))
});
}
}
}
}
================================================
FILE: tracers-codegen/src/gen/mod.rs
================================================
//! This is the main module for all code generators, both the build-time generators invoked from
//! `build.rs` and the generators used by the proc macros. There are multiple implementations of
//! these generators for the various tracing implementations, though only one can be active at
//! compile time, via conditonal compilation
use crate::build_rs::BuildInfo;
use crate::error::TracersResult;
use crate::spec::{ProbeCallSpecification, ProviderInitSpecification, ProviderSpecification};
use crate::TracingType;
use proc_macro2::TokenStream;
use serde::{Deserialize, Serialize};
use std::io::Write;
use std::path::{Path, PathBuf};
//mod c;
pub(crate) mod common;
pub(crate) mod dynamic;
pub(crate) mod r#static;
/// The native code generation step produces one or more libraries that the tracing application
/// must link to in order to function properly.
///
/// These can be different kinds of libraries which must be handled differently.
///
/// If it's a library that contains C wrapper functions around the native tracing API, that is a
/// static library that is linked via the `#[link]` attribute on the `extern` declaration produced
/// by the code generator.
///
/// However the native tracing API sometimes requires supporting libraries, either static or
/// dynamic. These must be linked explicitly by printing specially formated links to stdout in the
/// `build.rs` script so Cargo knows where to find the libs.
#[derive(Serialize, Deserialize, Debug, PartialEq, PartialOrd)]
pub(crate) enum NativeLib {
/// The name (minus `lib` prefix and `.a` or `.lib` suffix) of the generated static wrapper
/// lib. This should be linked by the `#[tracer]` macro so it will not be passed to cargo to
/// link
StaticWrapperLib(String),
/// A path where the static wrapper lib should be looked for. This will be passed to cargo as
/// one of the native library search paths
StaticWrapperLibPath(PathBuf),
/// The name of a dynamically-linked support lib. This will be explicitly linked to all
/// targets of the package
DynamicSupportLib(String),
/// The name of a statically-linked support lib. This will be explicitly linked to all
/// targets of the package
StaticSupportLib(String),
/// A path where support libs can be found. This will be passed to cargo as
/// one of the native library search paths
SupportLibPath(PathBuf),
}
/// Each probing implementation must implement this trait, which has components which are called at
/// build-time from `build.rs` and also components invoked by the macros at compile time. Though
/// invoked in very different contexts, there is much overlap and thus it makes sense to provide
/// them all in one trait implementation.
pub(crate) trait CodeGenerator {
/// Invoked by the `tracer` attribute macro to process a probing provider declaration and
/// generate whatever code is required there.
fn handle_provider_trait(&self, provider: ProviderSpecification) -> TracersResult<TokenStream>;
/// Invoked by the `probe!` macro to (conditionally) fire a probe.
fn handle_probe_call(&self, call: ProbeCallSpecification) -> TracersResult<TokenStream>;
/// Invoked by the `init_provider!` macro to (optionally) initialize the provider, although one
/// requirement of all implementations is that explicit initialization is not required and will
/// be done lazily on first use.
fn handle_init_provider(&self, init: ProviderInitSpecification) -> TracersResult<TokenStream>;
/// This is invoked from within `build.rs` of the crate which is dependent upon `tracers`. It
/// doesn't take much arguments because it interacts directly with cargo via environment
/// variables and stdout/stderr.
///
/// It is designed not to panic; if there is a hard stop that should cause the dependent crate
/// to fail, then it returns an error. Most errors won't be hard stops, but merely warnings
/// that cause the probing system to switch to a no-nop implementation
fn generate_native_code(
&self,
stdout: &mut dyn Write,
manifest_dir: &Path,
out_dir: &Path,
package_name: &str,
targets: Vec<PathBuf>,
) -> Vec<NativeLib>;
}
/// Loads the `BuildInfo` and based on its contents creates and returns the applicable
/// `CodeGenerator` implementation
pub(crate) fn code_generator() -> TracersResult<Box<dyn CodeGenerator>> {
let bi = BuildInfo::load()?;
Ok(match bi.implementation.tracing_type() {
//There are two implementations: one for static tracing (`disabled` is a special case of
//`static`), and one for dynamic
TracingType::Disabled | TracingType::Static => Box::new(r#static::StaticGenerator::new(bi)),
TracingType::Dynamic => Box::new(dynamic::DynamicGenerator::new(bi)),
})
}
================================================
FILE: tracers-codegen/src/gen/static/c.rs
================================================
//! Generates C code which implements each probe in terms of the target platform's tracing system,
//! if there is one.
use crate::cache;
use crate::probe_spec::ProbeSpecification;
use crate::provider_discovery::ProviderSpecification;
use askama::Template;
use failure::Fallible;
use std::fs::File;
use std::io::{BufWriter, Write};
use std::path::Path;
use std::path::PathBuf;
/// Given a tracing provider, generates the (C/C++) code to wrap the probes in a Rust-callable C
/// form.
///
/// On success, returns the path to the generated source file. This will be somewhere in the
/// `cache_path`, and if something already exists for this provider then it should be re-used.
pub(crate) fn generate_provider_funcs(
cache_path: &Path,
provider: &ProviderSpecification,
) -> Fallible<PathBuf> {
let file_name = provider.static_provider_source_filename();
//Make an internal func so we can use the `?` operator which inexplicably doesn't work in
//closures
cache::cache_generated_file(cache_path, &file_name, |abs_path| {
generate_source_file(provider, abs_path)
})
}
//The awsome Askama templating crate works by declaring structs that will contain the info we need
#[derive(Template)]
#[template(path = "provider_wrapper.c", escape = "none")]
struct SourceFile<'a> {
package_name: &'a str,
package_version: &'a str,
trait_name: String,
trait_token_stream: String,
provider_name: &'a str,
provider_name_with_hash: String,
probes: Vec<Probe<'a>>,
}
impl<'a> SourceFile<'a> {
fn from_provider_spec<'b: 'a>(provider: &'b ProviderSpecification) -> SourceFile<'a> {
let probes: Vec<_> = provider
.probes
.iter()
.map(|probe| Probe::from_probe_spec(provider, probe))
.collect();
SourceFile {
package_name: env!("CARGO_PKG_NAME"),
package_version: env!("CARGO_PKG_VERSION"),
trait_name: provider.item_trait.ident.to_string(),
trait_token_stream: provider.token_stream.to_string(),
provider_name: &provider.name,
provider_name_with_hash: provider.name_with_hash(),
probes: probes,
}
}
}
struct Probe<'a> {
name: &'a str,
args: Vec<ProbeArg>,
}
impl<'a> Probe<'a> {
fn from_probe_spec<'b: 'a>(
provider: &'b ProviderSpecification,
probe: &'b ProbeSpecification,
) -> Probe<'a> {
let args: Vec<_> = probe
.args
.iter()
.map(|(name, typ)| ProbeArg::new(name.ident.to_string(), typ.to_string()))
.collect();
Probe {
name: &probe.name,
args: args,
}
}
}
struct ProbeArg {
name: String,
c_type: String,
}
impl ProbeArg {
fn new(name: String, typ: String) -> ProbeArg {
ProbeArg { name, c_type: typ }
}
}
fn generate_source_file(provider: &ProviderSpecification, abs_path: PathBuf) -> Fallible<PathBuf> {
let mut file = File::create(&abs_path)?;
let mut writer = BufWriter::new(&mut file);
//Build the structures which will serve as input to the template engine
write!(
writer,
r###"
/** This file automatically generated by {package_name} {package_version}. Do not edit
* this file.
*
* This file contains static wrappers for the probes defined in trait {trait_name}.
*
* The source code for that trait is:
*
* ```rust
* {trait_tokenstream}
* ```
*/
"###,
package_name = env!("CARGO_PKG_NAME"),
package_version = env!("CARGO_PKG_VERSION"),
trait_name = provider.item_trait.ident,
trait_tokenstream = provider.token_stream
)?;
write!(
writer,
r###"
#include <sys/sdt.h>
extern "C" {{
"###
)?;
//for probe in provider.probes.iter() {
// generate_probe_wrapper(provider, probe, &writer)?
//}
write!(writer, "}}\n")?;
Ok(abs_path)
}
================================================
FILE: tracers-codegen/src/gen/static/mod.rs
================================================
//! This module contains the code to support the static style of probing, which is more like the
//! static C support for user-mode tracing used by DTrace, SystemTap USDT, and DTrace USDT. This
//! uses custom code running in the caller's `build.rs` to generate and compiler small C++ stubs
//! for each provider, which are implementing using the target tracing platform's own macros. This
//! has a number of advantages over the implementation in `dynamic`:
//!
//! * The probes are embedded in the resulting binary, and can be discovered by system tools like
//! `tplist`, `bpftrace`, etc.
//! * This is the way the platform-specific tracing systems are intended to work. Libraries that
//! implement dynamic tracing do so in a way that is, at best, a hack, and is poorly supported by
//! the static tools.
//! * This is much faster. The Rust code will still incurr one method call when a probe is
//! enabled, which would not be incurred by equivalent static code. But otherwise it's identical
//! to the static code implementation. In limited cases when cross-language LTO is possible, the
//! optimizer can even remove this method call and produce the same performance as static C code.
//!
//! The only reason the `dynamic` implementation exists is that I wrote it first, before I figured
//! out how to make `static` work reliable.
use super::NativeLib;
use crate::build_rs::BuildInfo;
use crate::gen::common;
use crate::spec::ProbeCallSpecification;
use crate::spec::ProviderInitSpecification;
use crate::spec::ProviderSpecification;
use crate::{gen::CodeGenerator, TracersResult};
use proc_macro2::TokenStream;
use std::io::Write;
use std::path::{Path, PathBuf};
mod native_code;
mod probe_call;
mod provider_trait;
pub(crate) struct StaticGenerator {
build_info: BuildInfo,
}
impl StaticGenerator {
gitextract_mpfftwx2/
├── .cirrus.yml
├── .gitignore
├── .gitmodules
├── .tmuxp.yaml
├── Cargo.toml
├── LICENSE
├── LICENSE-APACHE
├── LICENSE-MIT
├── README.md
├── azure-pipelines.yml
├── bin/
│ ├── pre-publish.sh
│ └── publish.sh
├── examples/
│ └── simple/
│ ├── Cargo.toml
│ ├── build.rs
│ └── src/
│ └── main.rs
├── scripts/
│ ├── build.bat
│ ├── build.sh
│ ├── test.bat
│ └── test.sh
├── tracers/
│ ├── Cargo.toml
│ ├── benches/
│ │ └── probe_firing.rs
│ ├── build.rs
│ ├── examples/
│ │ ├── simple.rs
│ │ └── submodules.rs
│ ├── src/
│ │ ├── bin/
│ │ │ ├── profile_target.rs
│ │ │ ├── stap_probes.d
│ │ │ ├── stap_probes.h
│ │ │ ├── stap_probes.o
│ │ │ ├── stap_probes.o.dtrace-temp.c
│ │ │ └── testfire.rs
│ │ └── lib.rs
│ └── tests/
│ ├── custom_provider_names.rs
│ └── simple.rs
├── tracers-build/
│ ├── Cargo.toml
│ └── src/
│ └── lib.rs
├── tracers-codegen/
│ ├── Cargo.toml
│ ├── src/
│ │ ├── argtypes.rs
│ │ ├── build_rs.rs
│ │ ├── cache.rs
│ │ ├── cargo.rs
│ │ ├── deps.rs
│ │ ├── error.rs
│ │ ├── gen/
│ │ │ ├── common/
│ │ │ │ └── mod.rs
│ │ │ ├── dynamic/
│ │ │ │ ├── mod.rs
│ │ │ │ ├── probe_call.rs
│ │ │ │ └── provider_trait.rs
│ │ │ ├── mod.rs
│ │ │ └── static/
│ │ │ ├── c.rs
│ │ │ ├── mod.rs
│ │ │ ├── native_code/
│ │ │ │ ├── .gitignore
│ │ │ │ ├── mod.rs
│ │ │ │ └── target/
│ │ │ │ ├── lttng.rs
│ │ │ │ ├── mod.rs
│ │ │ │ └── stap.rs
│ │ │ ├── probe_call.rs
│ │ │ └── provider_trait.rs
│ │ ├── hashing.rs
│ │ ├── lib.rs
│ │ ├── proc_macros.rs
│ │ ├── serde_helpers.rs
│ │ ├── spec/
│ │ │ ├── init_provider.rs
│ │ │ ├── mod.rs
│ │ │ ├── probe.rs
│ │ │ ├── probe_arg.rs
│ │ │ ├── probe_call.rs
│ │ │ └── provider.rs
│ │ ├── syn_helpers.rs
│ │ └── testdata.rs
│ ├── templates/
│ │ ├── lttng/
│ │ │ ├── provider.tp
│ │ │ └── provider_wrapper.cpp
│ │ └── stap/
│ │ ├── provider_wrapper.cpp
│ │ └── sys_sdt.h
│ └── testdata/
│ ├── complexlib/
│ │ ├── Cargo.toml
│ │ ├── build.rs
│ │ ├── examples/
│ │ │ └── ex1.rs
│ │ ├── src/
│ │ │ ├── bin/
│ │ │ │ ├── bin1.rs
│ │ │ │ └── bin2.rs
│ │ │ └── lib.rs
│ │ └── tests/
│ │ ├── static/
│ │ │ └── mod.rs
│ │ ├── test1.rs
│ │ └── test2.rs
│ ├── errors/
│ │ ├── Cargo.toml
│ │ ├── src/
│ │ │ ├── child_mod/
│ │ │ │ ├── grandchild_mod.rs
│ │ │ │ └── mod.rs
│ │ │ └── main.rs
│ │ └── tests/
│ │ ├── compile_errors.rs
│ │ └── with_errors/
│ │ └── mod.rs
│ ├── simplebin/
│ │ ├── Cargo.toml
│ │ └── src/
│ │ ├── child_module.rs
│ │ └── main.rs
│ └── simplelib/
│ ├── Cargo.toml
│ ├── build.rs
│ └── src/
│ ├── child_module.rs
│ └── lib.rs
├── tracers-core/
│ ├── Cargo.toml
│ ├── build.rs
│ └── src/
│ ├── argtypes/
│ │ ├── bool.rs
│ │ ├── cstring.rs
│ │ ├── int.rs
│ │ ├── native.rs
│ │ ├── option.rs
│ │ ├── pointer.rs
│ │ ├── refs.rs
│ │ └── string.rs
│ ├── argtypes.rs
│ ├── dynamic.rs
│ └── lib.rs
├── tracers-dyn-noop/
│ ├── Cargo.toml
│ ├── build.rs
│ └── src/
│ ├── lib.rs
│ ├── probe.rs
│ ├── provider.rs
│ └── tracer.rs
├── tracers-dyn-stap/
│ ├── Cargo.toml
│ ├── build.rs
│ └── src/
│ ├── lib.rs
│ ├── probe.rs
│ ├── provider.rs
│ └── tracer.rs
├── tracers-libelf-sys/
│ ├── COPYING-LGPLV3
│ ├── Cargo.toml
│ ├── LICENSE
│ ├── bindgen.sh
│ ├── build.rs
│ ├── src/
│ │ ├── lib.h
│ │ ├── lib.rs
│ │ └── libelf.rs
│ ├── update-elfutils.sh
│ └── vendor/
│ └── libelf/
│ ├── ABOUT-NLS
│ ├── AUTHORS
│ ├── CONTRIBUTING
│ ├── COPYING
│ ├── COPYING-GPLV2
│ ├── COPYING-LGPLV3
│ ├── ChangeLog
│ ├── GPG-KEY
│ ├── INSTALL
│ ├── Makefile.am
│ ├── Makefile.in
│ ├── NEWS
│ ├── NOTES
│ ├── README
│ ├── THANKS
│ ├── TODO
│ ├── aclocal.m4
│ ├── backends/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── aarch64_cfi.c
│ │ ├── aarch64_corenote.c
│ │ ├── aarch64_init.c
│ │ ├── aarch64_initreg.c
│ │ ├── aarch64_regs.c
│ │ ├── aarch64_reloc.def
│ │ ├── aarch64_retval.c
│ │ ├── aarch64_symbol.c
│ │ ├── aarch64_unwind.c
│ │ ├── alpha_auxv.c
│ │ ├── alpha_corenote.c
│ │ ├── alpha_init.c
│ │ ├── alpha_regs.c
│ │ ├── alpha_reloc.def
│ │ ├── alpha_retval.c
│ │ ├── alpha_symbol.c
│ │ ├── arm_attrs.c
│ │ ├── arm_auxv.c
│ │ ├── arm_cfi.c
│ │ ├── arm_corenote.c
│ │ ├── arm_init.c
│ │ ├── arm_initreg.c
│ │ ├── arm_regs.c
│ │ ├── arm_reloc.def
│ │ ├── arm_retval.c
│ │ ├── arm_symbol.c
│ │ ├── bpf_init.c
│ │ ├── bpf_regs.c
│ │ ├── bpf_reloc.def
│ │ ├── bpf_symbol.c
│ │ ├── common-reloc.c
│ │ ├── i386_auxv.c
│ │ ├── i386_cfi.c
│ │ ├── i386_corenote.c
│ │ ├── i386_init.c
│ │ ├── i386_initreg.c
│ │ ├── i386_regs.c
│ │ ├── i386_reloc.def
│ │ ├── i386_retval.c
│ │ ├── i386_symbol.c
│ │ ├── i386_syscall.c
│ │ ├── i386_unwind.c
│ │ ├── ia64_init.c
│ │ ├── ia64_regs.c
│ │ ├── ia64_reloc.def
│ │ ├── ia64_retval.c
│ │ ├── ia64_symbol.c
│ │ ├── libebl_CPU.h
│ │ ├── linux-core-note.c
│ │ ├── m68k_cfi.c
│ │ ├── m68k_corenote.c
│ │ ├── m68k_init.c
│ │ ├── m68k_initreg.c
│ │ ├── m68k_regs.c
│ │ ├── m68k_reloc.def
│ │ ├── m68k_retval.c
│ │ ├── m68k_symbol.c
│ │ ├── ppc64_corenote.c
│ │ ├── ppc64_init.c
│ │ ├── ppc64_reloc.def
│ │ ├── ppc64_resolve_sym.c
│ │ ├── ppc64_retval.c
│ │ ├── ppc64_symbol.c
│ │ ├── ppc64_unwind.c
│ │ ├── ppc_attrs.c
│ │ ├── ppc_auxv.c
│ │ ├── ppc_cfi.c
│ │ ├── ppc_corenote.c
│ │ ├── ppc_init.c
│ │ ├── ppc_initreg.c
│ │ ├── ppc_regs.c
│ │ ├── ppc_reloc.def
│ │ ├── ppc_retval.c
│ │ ├── ppc_symbol.c
│ │ ├── ppc_syscall.c
│ │ ├── riscv64_corenote.c
│ │ ├── riscv_cfi.c
│ │ ├── riscv_corenote.c
│ │ ├── riscv_init.c
│ │ ├── riscv_initreg.c
│ │ ├── riscv_regs.c
│ │ ├── riscv_reloc.def
│ │ ├── riscv_retval.c
│ │ ├── riscv_symbol.c
│ │ ├── s390_cfi.c
│ │ ├── s390_corenote.c
│ │ ├── s390_init.c
│ │ ├── s390_initreg.c
│ │ ├── s390_regs.c
│ │ ├── s390_reloc.def
│ │ ├── s390_retval.c
│ │ ├── s390_symbol.c
│ │ ├── s390_unwind.c
│ │ ├── s390x_corenote.c
│ │ ├── sh_corenote.c
│ │ ├── sh_init.c
│ │ ├── sh_regs.c
│ │ ├── sh_reloc.def
│ │ ├── sh_retval.c
│ │ ├── sh_symbol.c
│ │ ├── sparc64_corenote.c
│ │ ├── sparc_attrs.c
│ │ ├── sparc_auxv.c
│ │ ├── sparc_cfi.c
│ │ ├── sparc_corenote.c
│ │ ├── sparc_init.c
│ │ ├── sparc_initreg.c
│ │ ├── sparc_regs.c
│ │ ├── sparc_reloc.def
│ │ ├── sparc_retval.c
│ │ ├── sparc_symbol.c
│ │ ├── tilegx_corenote.c
│ │ ├── tilegx_init.c
│ │ ├── tilegx_regs.c
│ │ ├── tilegx_reloc.def
│ │ ├── tilegx_retval.c
│ │ ├── tilegx_symbol.c
│ │ ├── x32_corenote.c
│ │ ├── x86_64_cfi.c
│ │ ├── x86_64_corenote.c
│ │ ├── x86_64_init.c
│ │ ├── x86_64_initreg.c
│ │ ├── x86_64_regs.c
│ │ ├── x86_64_reloc.def
│ │ ├── x86_64_retval.c
│ │ ├── x86_64_symbol.c
│ │ ├── x86_64_syscall.c
│ │ ├── x86_64_unwind.c
│ │ └── x86_corenote.c
│ ├── config/
│ │ ├── 10-default-yama-scope.conf
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── ar-lib
│ │ ├── compile
│ │ ├── config.guess
│ │ ├── config.sub
│ │ ├── depcomp
│ │ ├── elfutils.spec.in
│ │ ├── eu.am
│ │ ├── install-sh
│ │ ├── known-dwarf.awk
│ │ ├── libdw.pc.in
│ │ ├── libelf.pc.in
│ │ ├── missing
│ │ ├── test-driver
│ │ ├── version.h.in
│ │ └── ylwrap
│ ├── config.h.in
│ ├── configure
│ ├── configure.ac
│ ├── elfutils.spec
│ ├── lib/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── bpf.h
│ │ ├── color.c
│ │ ├── color.h
│ │ ├── crc32.c
│ │ ├── crc32_file.c
│ │ ├── dynamicsizehash.c
│ │ ├── dynamicsizehash.h
│ │ ├── eu-config.h
│ │ ├── fixedsizehash.h
│ │ ├── libeu.h
│ │ ├── list.h
│ │ ├── next_prime.c
│ │ ├── printversion.c
│ │ ├── printversion.h
│ │ ├── system.h
│ │ ├── xmalloc.c
│ │ ├── xstrdup.c
│ │ └── xstrndup.c
│ ├── libasm/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── asm_abort.c
│ │ ├── asm_addint16.c
│ │ ├── asm_addint32.c
│ │ ├── asm_addint64.c
│ │ ├── asm_addint8.c
│ │ ├── asm_addsleb128.c
│ │ ├── asm_addstrz.c
│ │ ├── asm_adduint16.c
│ │ ├── asm_adduint32.c
│ │ ├── asm_adduint64.c
│ │ ├── asm_adduint8.c
│ │ ├── asm_adduleb128.c
│ │ ├── asm_align.c
│ │ ├── asm_begin.c
│ │ ├── asm_end.c
│ │ ├── asm_error.c
│ │ ├── asm_fill.c
│ │ ├── asm_getelf.c
│ │ ├── asm_newabssym.c
│ │ ├── asm_newcomsym.c
│ │ ├── asm_newscn.c
│ │ ├── asm_newscn_ingrp.c
│ │ ├── asm_newscngrp.c
│ │ ├── asm_newsubscn.c
│ │ ├── asm_newsym.c
│ │ ├── asm_scngrp_newsignature.c
│ │ ├── disasm_begin.c
│ │ ├── disasm_cb.c
│ │ ├── disasm_end.c
│ │ ├── disasm_str.c
│ │ ├── libasm.h
│ │ ├── libasmP.h
│ │ ├── symbolhash.c
│ │ └── symbolhash.h
│ ├── libcpu/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── bpf_disasm.c
│ │ ├── defs/
│ │ │ └── i386
│ │ ├── i386_data.h
│ │ ├── i386_dis.h
│ │ ├── i386_disasm.c
│ │ ├── i386_gendis.c
│ │ ├── i386_lex.c
│ │ ├── i386_lex.l
│ │ ├── i386_parse.c
│ │ ├── i386_parse.h
│ │ ├── i386_parse.y
│ │ ├── memory-access.h
│ │ ├── x86_64_dis.h
│ │ └── x86_64_disasm.c
│ ├── libdw/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── cfi.c
│ │ ├── cfi.h
│ │ ├── cie.c
│ │ ├── dwarf.h
│ │ ├── dwarf_abbrev_hash.c
│ │ ├── dwarf_abbrev_hash.h
│ │ ├── dwarf_abbrevhaschildren.c
│ │ ├── dwarf_addrdie.c
│ │ ├── dwarf_aggregate_size.c
│ │ ├── dwarf_arrayorder.c
│ │ ├── dwarf_attr.c
│ │ ├── dwarf_attr_integrate.c
│ │ ├── dwarf_begin.c
│ │ ├── dwarf_begin_elf.c
│ │ ├── dwarf_bitoffset.c
│ │ ├── dwarf_bitsize.c
│ │ ├── dwarf_bytesize.c
│ │ ├── dwarf_cfi_addrframe.c
│ │ ├── dwarf_cfi_end.c
│ │ ├── dwarf_child.c
│ │ ├── dwarf_cu_die.c
│ │ ├── dwarf_cu_getdwarf.c
│ │ ├── dwarf_cu_info.c
│ │ ├── dwarf_cuoffset.c
│ │ ├── dwarf_decl_column.c
│ │ ├── dwarf_decl_file.c
│ │ ├── dwarf_decl_line.c
│ │ ├── dwarf_default_lower_bound.c
│ │ ├── dwarf_die_addr_die.c
│ │ ├── dwarf_diecu.c
│ │ ├── dwarf_diename.c
│ │ ├── dwarf_dieoffset.c
│ │ ├── dwarf_end.c
│ │ ├── dwarf_entry_breakpoints.c
│ │ ├── dwarf_entrypc.c
│ │ ├── dwarf_error.c
│ │ ├── dwarf_filesrc.c
│ │ ├── dwarf_formaddr.c
│ │ ├── dwarf_formblock.c
│ │ ├── dwarf_formflag.c
│ │ ├── dwarf_formref.c
│ │ ├── dwarf_formref_die.c
│ │ ├── dwarf_formsdata.c
│ │ ├── dwarf_formstring.c
│ │ ├── dwarf_formudata.c
│ │ ├── dwarf_frame_cfa.c
│ │ ├── dwarf_frame_info.c
│ │ ├── dwarf_frame_register.c
│ │ ├── dwarf_func_inline.c
│ │ ├── dwarf_get_units.c
│ │ ├── dwarf_getabbrev.c
│ │ ├── dwarf_getabbrevattr.c
│ │ ├── dwarf_getabbrevcode.c
│ │ ├── dwarf_getabbrevtag.c
│ │ ├── dwarf_getalt.c
│ │ ├── dwarf_getarange_addr.c
│ │ ├── dwarf_getarangeinfo.c
│ │ ├── dwarf_getaranges.c
│ │ ├── dwarf_getattrcnt.c
│ │ ├── dwarf_getattrs.c
│ │ ├── dwarf_getcfi.c
│ │ ├── dwarf_getcfi_elf.c
│ │ ├── dwarf_getelf.c
│ │ ├── dwarf_getfuncs.c
│ │ ├── dwarf_getlocation.c
│ │ ├── dwarf_getlocation_attr.c
│ │ ├── dwarf_getlocation_die.c
│ │ ├── dwarf_getlocation_implicit_pointer.c
│ │ ├── dwarf_getmacros.c
│ │ ├── dwarf_getpubnames.c
│ │ ├── dwarf_getscopes.c
│ │ ├── dwarf_getscopes_die.c
│ │ ├── dwarf_getscopevar.c
│ │ ├── dwarf_getsrc_die.c
│ │ ├── dwarf_getsrc_file.c
│ │ ├── dwarf_getsrcdirs.c
│ │ ├── dwarf_getsrcfiles.c
│ │ ├── dwarf_getsrclines.c
│ │ ├── dwarf_getstring.c
│ │ ├── dwarf_hasattr.c
│ │ ├── dwarf_hasattr_integrate.c
│ │ ├── dwarf_haschildren.c
│ │ ├── dwarf_hasform.c
│ │ ├── dwarf_haspc.c
│ │ ├── dwarf_highpc.c
│ │ ├── dwarf_line_file.c
│ │ ├── dwarf_lineaddr.c
│ │ ├── dwarf_linebeginstatement.c
│ │ ├── dwarf_lineblock.c
│ │ ├── dwarf_linecol.c
│ │ ├── dwarf_linediscriminator.c
│ │ ├── dwarf_lineendsequence.c
│ │ ├── dwarf_lineepiloguebegin.c
│ │ ├── dwarf_lineisa.c
│ │ ├── dwarf_lineno.c
│ │ ├── dwarf_lineop_index.c
│ │ ├── dwarf_lineprologueend.c
│ │ ├── dwarf_linesrc.c
│ │ ├── dwarf_lowpc.c
│ │ ├── dwarf_macro_getparamcnt.c
│ │ ├── dwarf_macro_getsrcfiles.c
│ │ ├── dwarf_macro_opcode.c
│ │ ├── dwarf_macro_param.c
│ │ ├── dwarf_macro_param1.c
│ │ ├── dwarf_macro_param2.c
│ │ ├── dwarf_next_cfi.c
│ │ ├── dwarf_next_lines.c
│ │ ├── dwarf_nextcu.c
│ │ ├── dwarf_offabbrev.c
│ │ ├── dwarf_offdie.c
│ │ ├── dwarf_onearange.c
│ │ ├── dwarf_onesrcline.c
│ │ ├── dwarf_peel_type.c
│ │ ├── dwarf_ranges.c
│ │ ├── dwarf_setalt.c
│ │ ├── dwarf_siblingof.c
│ │ ├── dwarf_sig8_hash.c
│ │ ├── dwarf_sig8_hash.h
│ │ ├── dwarf_srclang.c
│ │ ├── dwarf_tag.c
│ │ ├── dwarf_whatattr.c
│ │ ├── dwarf_whatform.c
│ │ ├── encoded-value.h
│ │ ├── fde.c
│ │ ├── frame-cache.c
│ │ ├── known-dwarf.h
│ │ ├── libdw.h
│ │ ├── libdwP.h
│ │ ├── libdw_alloc.c
│ │ ├── libdw_find_split_unit.c
│ │ ├── libdw_findcu.c
│ │ ├── libdw_form.c
│ │ ├── libdw_visit_scopes.c
│ │ └── memory-access.h
│ ├── libdwelf/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── dwelf_dwarf_gnu_debugaltlink.c
│ │ ├── dwelf_elf_begin.c
│ │ ├── dwelf_elf_gnu_build_id.c
│ │ ├── dwelf_elf_gnu_debuglink.c
│ │ ├── dwelf_scn_gnu_compressed_size.c
│ │ ├── dwelf_strtab.c
│ │ ├── libdwelf.h
│ │ └── libdwelfP.h
│ ├── libdwfl/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── argp-std.c
│ │ ├── bzip2.c
│ │ ├── core-file.c
│ │ ├── cu.c
│ │ ├── derelocate.c
│ │ ├── dwfl_addrdie.c
│ │ ├── dwfl_addrdwarf.c
│ │ ├── dwfl_addrmodule.c
│ │ ├── dwfl_begin.c
│ │ ├── dwfl_build_id_find_debuginfo.c
│ │ ├── dwfl_build_id_find_elf.c
│ │ ├── dwfl_cumodule.c
│ │ ├── dwfl_dwarf_line.c
│ │ ├── dwfl_end.c
│ │ ├── dwfl_error.c
│ │ ├── dwfl_frame.c
│ │ ├── dwfl_frame_pc.c
│ │ ├── dwfl_frame_regs.c
│ │ ├── dwfl_getdwarf.c
│ │ ├── dwfl_getmodules.c
│ │ ├── dwfl_getsrc.c
│ │ ├── dwfl_getsrclines.c
│ │ ├── dwfl_line_comp_dir.c
│ │ ├── dwfl_linecu.c
│ │ ├── dwfl_lineinfo.c
│ │ ├── dwfl_linemodule.c
│ │ ├── dwfl_module.c
│ │ ├── dwfl_module_addrdie.c
│ │ ├── dwfl_module_addrname.c
│ │ ├── dwfl_module_addrsym.c
│ │ ├── dwfl_module_build_id.c
│ │ ├── dwfl_module_dwarf_cfi.c
│ │ ├── dwfl_module_eh_cfi.c
│ │ ├── dwfl_module_getdwarf.c
│ │ ├── dwfl_module_getelf.c
│ │ ├── dwfl_module_getsrc.c
│ │ ├── dwfl_module_getsrc_file.c
│ │ ├── dwfl_module_getsym.c
│ │ ├── dwfl_module_info.c
│ │ ├── dwfl_module_nextcu.c
│ │ ├── dwfl_module_register_names.c
│ │ ├── dwfl_module_report_build_id.c
│ │ ├── dwfl_module_return_value_location.c
│ │ ├── dwfl_nextcu.c
│ │ ├── dwfl_onesrcline.c
│ │ ├── dwfl_report_elf.c
│ │ ├── dwfl_segment_report_module.c
│ │ ├── dwfl_validate_address.c
│ │ ├── dwfl_version.c
│ │ ├── elf-from-memory.c
│ │ ├── find-debuginfo.c
│ │ ├── frame_unwind.c
│ │ ├── gzip.c
│ │ ├── image-header.c
│ │ ├── libdwfl.h
│ │ ├── libdwflP.h
│ │ ├── libdwfl_crc32.c
│ │ ├── libdwfl_crc32_file.c
│ │ ├── lines.c
│ │ ├── link_map.c
│ │ ├── linux-core-attach.c
│ │ ├── linux-kernel-modules.c
│ │ ├── linux-pid-attach.c
│ │ ├── linux-proc-maps.c
│ │ ├── lzma.c
│ │ ├── offline.c
│ │ ├── open.c
│ │ ├── relocate.c
│ │ └── segment.c
│ ├── libebl/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── ebl-hooks.h
│ │ ├── ebl_check_special_section.c
│ │ ├── ebl_check_special_symbol.c
│ │ ├── ebl_data_marker_symbol.c
│ │ ├── ebl_syscall_abi.c
│ │ ├── eblabicfi.c
│ │ ├── eblauxvinfo.c
│ │ ├── eblbackendname.c
│ │ ├── eblbsspltp.c
│ │ ├── eblcheckobjattr.c
│ │ ├── eblcheckreloctargettype.c
│ │ ├── eblclosebackend.c
│ │ ├── eblcopyrelocp.c
│ │ ├── eblcorenote.c
│ │ ├── eblcorenotetypename.c
│ │ ├── ebldebugscnp.c
│ │ ├── ebldwarftoregno.c
│ │ ├── ebldynamictagcheck.c
│ │ ├── ebldynamictagname.c
│ │ ├── eblelfclass.c
│ │ ├── eblelfdata.c
│ │ ├── eblelfmachine.c
│ │ ├── eblgotpcreloccheck.c
│ │ ├── eblinitreg.c
│ │ ├── eblmachineflagcheck.c
│ │ ├── eblmachineflagname.c
│ │ ├── eblmachinesectionflagcheck.c
│ │ ├── eblnonerelocp.c
│ │ ├── eblnormalizepc.c
│ │ ├── eblobjnote.c
│ │ ├── eblobjnotetypename.c
│ │ ├── eblopenbackend.c
│ │ ├── eblosabiname.c
│ │ ├── eblreginfo.c
│ │ ├── eblrelativerelocp.c
│ │ ├── eblrelocsimpletype.c
│ │ ├── eblreloctypecheck.c
│ │ ├── eblreloctypename.c
│ │ ├── eblrelocvaliduse.c
│ │ ├── eblresolvesym.c
│ │ ├── eblretval.c
│ │ ├── eblsectionname.c
│ │ ├── eblsectionstripp.c
│ │ ├── eblsectiontypename.c
│ │ ├── eblsegmenttypename.c
│ │ ├── eblstother.c
│ │ ├── eblsymbolbindingname.c
│ │ ├── eblsymboltypename.c
│ │ ├── eblsysvhashentrysize.c
│ │ ├── eblunwind.c
│ │ ├── libebl.h
│ │ └── libeblP.h
│ ├── libelf/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── abstract.h
│ │ ├── chdr_xlate.h
│ │ ├── common.h
│ │ ├── dl-hash.h
│ │ ├── elf-knowledge.h
│ │ ├── elf.h
│ │ ├── elf32_checksum.c
│ │ ├── elf32_fsize.c
│ │ ├── elf32_getchdr.c
│ │ ├── elf32_getehdr.c
│ │ ├── elf32_getphdr.c
│ │ ├── elf32_getshdr.c
│ │ ├── elf32_newehdr.c
│ │ ├── elf32_newphdr.c
│ │ ├── elf32_offscn.c
│ │ ├── elf32_updatefile.c
│ │ ├── elf32_updatenull.c
│ │ ├── elf32_xlatetof.c
│ │ ├── elf32_xlatetom.c
│ │ ├── elf64_checksum.c
│ │ ├── elf64_fsize.c
│ │ ├── elf64_getchdr.c
│ │ ├── elf64_getehdr.c
│ │ ├── elf64_getphdr.c
│ │ ├── elf64_getshdr.c
│ │ ├── elf64_newehdr.c
│ │ ├── elf64_newphdr.c
│ │ ├── elf64_offscn.c
│ │ ├── elf64_updatefile.c
│ │ ├── elf64_updatenull.c
│ │ ├── elf64_xlatetof.c
│ │ ├── elf64_xlatetom.c
│ │ ├── elf_begin.c
│ │ ├── elf_clone.c
│ │ ├── elf_cntl.c
│ │ ├── elf_compress.c
│ │ ├── elf_compress_gnu.c
│ │ ├── elf_end.c
│ │ ├── elf_error.c
│ │ ├── elf_fill.c
│ │ ├── elf_flagdata.c
│ │ ├── elf_flagehdr.c
│ │ ├── elf_flagelf.c
│ │ ├── elf_flagphdr.c
│ │ ├── elf_flagscn.c
│ │ ├── elf_flagshdr.c
│ │ ├── elf_getarhdr.c
│ │ ├── elf_getaroff.c
│ │ ├── elf_getarsym.c
│ │ ├── elf_getbase.c
│ │ ├── elf_getdata.c
│ │ ├── elf_getdata_rawchunk.c
│ │ ├── elf_getident.c
│ │ ├── elf_getphdrnum.c
│ │ ├── elf_getscn.c
│ │ ├── elf_getshdrnum.c
│ │ ├── elf_getshdrstrndx.c
│ │ ├── elf_gnu_hash.c
│ │ ├── elf_hash.c
│ │ ├── elf_kind.c
│ │ ├── elf_memory.c
│ │ ├── elf_ndxscn.c
│ │ ├── elf_newdata.c
│ │ ├── elf_newscn.c
│ │ ├── elf_next.c
│ │ ├── elf_nextscn.c
│ │ ├── elf_rand.c
│ │ ├── elf_rawdata.c
│ │ ├── elf_rawfile.c
│ │ ├── elf_readall.c
│ │ ├── elf_scnshndx.c
│ │ ├── elf_strptr.c
│ │ ├── elf_update.c
│ │ ├── elf_version.c
│ │ ├── exttypes.h
│ │ ├── gelf.h
│ │ ├── gelf_checksum.c
│ │ ├── gelf_fsize.c
│ │ ├── gelf_getauxv.c
│ │ ├── gelf_getchdr.c
│ │ ├── gelf_getclass.c
│ │ ├── gelf_getdyn.c
│ │ ├── gelf_getehdr.c
│ │ ├── gelf_getlib.c
│ │ ├── gelf_getmove.c
│ │ ├── gelf_getnote.c
│ │ ├── gelf_getphdr.c
│ │ ├── gelf_getrel.c
│ │ ├── gelf_getrela.c
│ │ ├── gelf_getshdr.c
│ │ ├── gelf_getsym.c
│ │ ├── gelf_getsyminfo.c
│ │ ├── gelf_getsymshndx.c
│ │ ├── gelf_getverdaux.c
│ │ ├── gelf_getverdef.c
│ │ ├── gelf_getvernaux.c
│ │ ├── gelf_getverneed.c
│ │ ├── gelf_getversym.c
│ │ ├── gelf_newehdr.c
│ │ ├── gelf_newphdr.c
│ │ ├── gelf_offscn.c
│ │ ├── gelf_update_auxv.c
│ │ ├── gelf_update_dyn.c
│ │ ├── gelf_update_ehdr.c
│ │ ├── gelf_update_lib.c
│ │ ├── gelf_update_move.c
│ │ ├── gelf_update_phdr.c
│ │ ├── gelf_update_rel.c
│ │ ├── gelf_update_rela.c
│ │ ├── gelf_update_shdr.c
│ │ ├── gelf_update_sym.c
│ │ ├── gelf_update_syminfo.c
│ │ ├── gelf_update_symshndx.c
│ │ ├── gelf_update_verdaux.c
│ │ ├── gelf_update_verdef.c
│ │ ├── gelf_update_vernaux.c
│ │ ├── gelf_update_verneed.c
│ │ ├── gelf_update_versym.c
│ │ ├── gelf_xlate.c
│ │ ├── gelf_xlate.h
│ │ ├── gelf_xlatetof.c
│ │ ├── gelf_xlatetom.c
│ │ ├── gnuhash_xlate.h
│ │ ├── libelf.h
│ │ ├── libelfP.h
│ │ ├── libelf_crc32.c
│ │ ├── libelf_next_prime.c
│ │ ├── nlist.c
│ │ ├── nlist.h
│ │ ├── note_xlate.h
│ │ └── version_xlate.h
│ ├── m4/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── biarch.m4
│ │ ├── codeset.m4
│ │ ├── gettext.m4
│ │ ├── iconv.m4
│ │ ├── lcmessage.m4
│ │ ├── nls.m4
│ │ ├── po.m4
│ │ ├── progtest.m4
│ │ └── zip.m4
│ ├── po/
│ │ ├── ChangeLog
│ │ ├── LINGUAS
│ │ ├── Makefile.in.in
│ │ ├── Makevars
│ │ ├── POTFILES.in
│ │ ├── Rules-quot
│ │ ├── boldquot.sed
│ │ ├── de.gmo
│ │ ├── de.po
│ │ ├── elfutils.pot
│ │ ├── en@boldquot.gmo
│ │ ├── en@boldquot.header
│ │ ├── en@boldquot.po
│ │ ├── en@quot.gmo
│ │ ├── en@quot.header
│ │ ├── en@quot.po
│ │ ├── es.gmo
│ │ ├── es.po
│ │ ├── insert-header.sin
│ │ ├── ja.gmo
│ │ ├── ja.po
│ │ ├── pl.gmo
│ │ ├── pl.po
│ │ ├── quot.sed
│ │ ├── remove-potcdate.sin
│ │ ├── stamp-po
│ │ ├── uk.gmo
│ │ └── uk.po
│ ├── src/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── addr2line.c
│ │ ├── ar.c
│ │ ├── arlib-argp.c
│ │ ├── arlib.c
│ │ ├── arlib.h
│ │ ├── arlib2.c
│ │ ├── debugpred.h
│ │ ├── elfcmp.c
│ │ ├── elfcompress.c
│ │ ├── elflint.c
│ │ ├── findtextrel.c
│ │ ├── make-debug-archive.in
│ │ ├── nm.c
│ │ ├── objdump.c
│ │ ├── ranlib.c
│ │ ├── readelf.c
│ │ ├── size.c
│ │ ├── stack.c
│ │ ├── strings.c
│ │ ├── strip.c
│ │ └── unstrip.c
│ ├── tests/
│ │ ├── ChangeLog
│ │ ├── Makefile.am
│ │ ├── Makefile.in
│ │ ├── addrcfi.c
│ │ ├── addrscopes.c
│ │ ├── addrx_constx-4.dwo.bz2
│ │ ├── addrx_constx-5.dwo.bz2
│ │ ├── addsections.c
│ │ ├── aggregate_size.c
│ │ ├── all-dwarf-ranges.c
│ │ ├── alldts.c
│ │ ├── allfcts.c
│ │ ├── allregs.c
│ │ ├── arextract.c
│ │ ├── arls.c
│ │ ├── arsymtest.c
│ │ ├── asm-tst1.c
│ │ ├── asm-tst2.c
│ │ ├── asm-tst3.c
│ │ ├── asm-tst4.c
│ │ ├── asm-tst5.c
│ │ ├── asm-tst6.c
│ │ ├── asm-tst7.c
│ │ ├── asm-tst8.c
│ │ ├── asm-tst9.c
│ │ ├── attr-integrate-skel.c
│ │ ├── backtrace-child.c
│ │ ├── backtrace-data.c
│ │ ├── backtrace-dwarf.c
│ │ ├── backtrace-subr.sh
│ │ ├── backtrace.aarch64.core.bz2
│ │ ├── backtrace.aarch64.exec.bz2
│ │ ├── backtrace.aarch64.fp.core.bz2
│ │ ├── backtrace.aarch64.fp.exec.bz2
│ │ ├── backtrace.c
│ │ ├── backtrace.i386.core.bz2
│ │ ├── backtrace.i386.exec.bz2
│ │ ├── backtrace.i386.fp.core.bz2
│ │ ├── backtrace.i386.fp.exec.bz2
│ │ ├── backtrace.ppc.core.bz2
│ │ ├── backtrace.ppc.exec.bz2
│ │ ├── backtrace.ppc64le.fp.core.bz2
│ │ ├── backtrace.ppc64le.fp.exec.bz2
│ │ ├── backtrace.s390.core.bz2
│ │ ├── backtrace.s390.exec.bz2
│ │ ├── backtrace.s390x.core.bz2
│ │ ├── backtrace.s390x.exec.bz2
│ │ ├── backtrace.sparc.core.bz2
│ │ ├── backtrace.sparc.exec.bz2
│ │ ├── backtrace.x32.core.bz2
│ │ ├── backtrace.x32.exec.bz2
│ │ ├── backtrace.x86_64.core.bz2
│ │ ├── backtrace.x86_64.exec.bz2
│ │ ├── backtrace.x86_64.fp.core.bz2
│ │ ├── backtrace.x86_64.fp.exec.bz2
│ │ ├── buildid.c
│ │ ├── cleanup-13.c
│ │ ├── coverage.sh
│ │ ├── debug-ranges-no-lowpc.o.bz2
│ │ ├── debugaltlink.c
│ │ ├── debuglink.c
│ │ ├── deleted-lib.c
│ │ ├── deleted.c
│ │ ├── dwarf-die-addr-die.c
│ │ ├── dwarf-getmacros.c
│ │ ├── dwarf-getstring.c
│ │ ├── dwarf-ranges.c
│ │ ├── dwarf_default_lower_bound.c
│ │ ├── dwarfcfi.c
│ │ ├── dwelfgnucompressed.c
│ │ ├── dwfl-addr-sect.c
│ │ ├── dwfl-bug-addr-overflow.c
│ │ ├── dwfl-bug-fd-leak.c
│ │ ├── dwfl-bug-getmodules.c
│ │ ├── dwfl-bug-report.c
│ │ ├── dwfl-proc-attach.c
│ │ ├── dwfl-report-elf-align.c
│ │ ├── dwfllines.c
│ │ ├── dwflmodtest.c
│ │ ├── dwflsyms.c
│ │ ├── early-offscn.c
│ │ ├── ecp.c
│ │ ├── elfcopy.c
│ │ ├── elfgetchdr.c
│ │ ├── elfgetzdata.c
│ │ ├── elfputzdata.c
│ │ ├── elfshphehdr.c
│ │ ├── elfstrmerge.c
│ │ ├── elfstrtab.c
│ │ ├── emptyfile.c
│ │ ├── fillfile.c
│ │ ├── find-prologues.c
│ │ ├── funcretval.c
│ │ ├── funcretval_test.c
│ │ ├── funcretval_test_aarch64.bz2
│ │ ├── funcscopes.c
│ │ ├── get-aranges.c
│ │ ├── get-files.c
│ │ ├── get-lines.c
│ │ ├── get-pubnames.c
│ │ ├── get-units-invalid.c
│ │ ├── get-units-split.c
│ │ ├── getsrc_die.c
│ │ ├── hash.c
│ │ ├── hello_aarch64.ko.bz2
│ │ ├── hello_i386.ko.bz2
│ │ ├── hello_m68k.ko.bz2
│ │ ├── hello_ppc64.ko.bz2
│ │ ├── hello_riscv64.ko.bz2
│ │ ├── hello_s390.ko.bz2
│ │ ├── hello_x86_64.ko.bz2
│ │ ├── lfs-symbols
│ │ ├── libtestfile_multi_shared.so.bz2
│ │ ├── line2addr.c
│ │ ├── linkmap-cut-lib.so.bz2
│ │ ├── linkmap-cut.bz2
│ │ ├── linkmap-cut.core.bz2
│ │ ├── low_high_pc.c
│ │ ├── msg_tst.c
│ │ ├── newdata.c
│ │ ├── newfile.c
│ │ ├── newscn.c
│ │ ├── next-files.c
│ │ ├── next-lines.c
│ │ ├── next_cfi.c
│ │ ├── peel_type.c
│ │ ├── rdwrmmap.c
│ │ ├── rerequest_tag.c
│ │ ├── run-addr2line-alt-debugpath.sh
│ │ ├── run-addr2line-i-demangle-test.sh
│ │ ├── run-addr2line-i-lex-test.sh
│ │ ├── run-addr2line-i-test.sh
│ │ ├── run-addr2line-test.sh
│ │ ├── run-addrcfi.sh
│ │ ├── run-addrname-test.sh
│ │ ├── run-addrscopes.sh
│ │ ├── run-aggregate-size.sh
│ │ ├── run-all-dwarf-ranges.sh
│ │ ├── run-alldts.sh
│ │ ├── run-allfcts-multi.sh
│ │ ├── run-allfcts.sh
│ │ ├── run-allregs.sh
│ │ ├── run-annobingroup.sh
│ │ ├── run-ar.sh
│ │ ├── run-arextract.sh
│ │ ├── run-arsymtest.sh
│ │ ├── run-attr-integrate-skel.sh
│ │ ├── run-backtrace-core-aarch64.sh
│ │ ├── run-backtrace-core-i386.sh
│ │ ├── run-backtrace-core-ppc.sh
│ │ ├── run-backtrace-core-s390.sh
│ │ ├── run-backtrace-core-s390x.sh
│ │ ├── run-backtrace-core-sparc.sh
│ │ ├── run-backtrace-core-x32.sh
│ │ ├── run-backtrace-core-x86_64.sh
│ │ ├── run-backtrace-data.sh
│ │ ├── run-backtrace-demangle.sh
│ │ ├── run-backtrace-dwarf.sh
│ │ ├── run-backtrace-fp-core-aarch64.sh
│ │ ├── run-backtrace-fp-core-i386.sh
│ │ ├── run-backtrace-fp-core-ppc64le.sh
│ │ ├── run-backtrace-fp-core-x86_64.sh
│ │ ├── run-backtrace-native-biarch.sh
│ │ ├── run-backtrace-native-core-biarch.sh
│ │ ├── run-backtrace-native-core.sh
│ │ ├── run-backtrace-native.sh
│ │ ├── run-bug1-test.sh
│ │ ├── run-buildid.sh
│ │ ├── run-compress-test.sh
│ │ ├── run-copyadd-sections.sh
│ │ ├── run-copymany-sections.sh
│ │ ├── run-debugaltlink.sh
│ │ ├── run-debuglink.sh
│ │ ├── run-deleted.sh
│ │ ├── run-disasm-bpf.sh
│ │ ├── run-disasm-x86-64.sh
│ │ ├── run-disasm-x86.sh
│ │ ├── run-dwarf-die-addr-die.sh
│ │ ├── run-dwarf-getmacros.sh
│ │ ├── run-dwarf-getstring.sh
│ │ ├── run-dwarf-ranges.sh
│ │ ├── run-dwarfcfi.sh
│ │ ├── run-dwelfgnucompressed.sh
│ │ ├── run-dwfl-addr-sect.sh
│ │ ├── run-dwfl-bug-offline-rel.sh
│ │ ├── run-dwfl-report-elf-align.sh
│ │ ├── run-dwfllines.sh
│ │ ├── run-dwflsyms.sh
│ │ ├── run-early-offscn.sh
│ │ ├── run-ecp-test.sh
│ │ ├── run-ecp-test2.sh
│ │ ├── run-elf_cntl_gelf_getshdr.sh
│ │ ├── run-elfgetchdr.sh
│ │ ├── run-elfgetzdata.sh
│ │ ├── run-elflint-self.sh
│ │ ├── run-elflint-test.sh
│ │ ├── run-elfputzdata.sh
│ │ ├── run-elfstrmerge-test.sh
│ │ ├── run-exprlocs-self.sh
│ │ ├── run-exprlocs.sh
│ │ ├── run-find-prologues.sh
│ │ ├── run-funcretval.sh
│ │ ├── run-funcscopes.sh
│ │ ├── run-get-aranges.sh
│ │ ├── run-get-files.sh
│ │ ├── run-get-lines.sh
│ │ ├── run-get-pubnames.sh
│ │ ├── run-get-units-invalid.sh
│ │ ├── run-get-units-split.sh
│ │ ├── run-getsrc-die.sh
│ │ ├── run-lfs-symbols.sh
│ │ ├── run-line2addr.sh
│ │ ├── run-linkmap-cut.sh
│ │ ├── run-low_high_pc.sh
│ │ ├── run-macro-test.sh
│ │ ├── run-native-test.sh
│ │ ├── run-next-cfi-self.sh
│ │ ├── run-next-cfi.sh
│ │ ├── run-next-files.sh
│ │ ├── run-next-lines.sh
│ │ ├── run-nm-self.sh
│ │ ├── run-peel-type.sh
│ │ ├── run-prelink-addr-test.sh
│ │ ├── run-ranlib-test.sh
│ │ ├── run-ranlib-test2.sh
│ │ ├── run-ranlib-test3.sh
│ │ ├── run-ranlib-test4.sh
│ │ ├── run-readelf-A.sh
│ │ ├── run-readelf-addr.sh
│ │ ├── run-readelf-aranges.sh
│ │ ├── run-readelf-compressed.sh
│ │ ├── run-readelf-const-values.sh
│ │ ├── run-readelf-d.sh
│ │ ├── run-readelf-dwz-multi.sh
│ │ ├── run-readelf-gdb_index.sh
│ │ ├── run-readelf-info-plus.sh
│ │ ├── run-readelf-line.sh
│ │ ├── run-readelf-loc.sh
│ │ ├── run-readelf-macro.sh
│ │ ├── run-readelf-mixed-corenote.sh
│ │ ├── run-readelf-n.sh
│ │ ├── run-readelf-ranges.sh
│ │ ├── run-readelf-s.sh
│ │ ├── run-readelf-self.sh
│ │ ├── run-readelf-str.sh
│ │ ├── run-readelf-test1.sh
│ │ ├── run-readelf-test2.sh
│ │ ├── run-readelf-test3.sh
│ │ ├── run-readelf-test4.sh
│ │ ├── run-readelf-twofiles.sh
│ │ ├── run-readelf-types.sh
│ │ ├── run-readelf-variant.sh
│ │ ├── run-readelf-vmcoreinfo.sh
│ │ ├── run-readelf-z.sh
│ │ ├── run-readelf-zdebug-rel.sh
│ │ ├── run-readelf-zdebug.sh
│ │ ├── run-readelf-zp.sh
│ │ ├── run-readelf-zx.sh
│ │ ├── run-reloc-bpf.sh
│ │ ├── run-rerequest_tag.sh
│ │ ├── run-show-abbrev.sh
│ │ ├── run-show-die-info.sh
│ │ ├── run-stack-d-test.sh
│ │ ├── run-stack-demangled-test.sh
│ │ ├── run-stack-i-test.sh
│ │ ├── run-strings-test.sh
│ │ ├── run-strip-g.sh
│ │ ├── run-strip-groups.sh
│ │ ├── run-strip-nobitsalign.sh
│ │ ├── run-strip-nothing.sh
│ │ ├── run-strip-reloc.sh
│ │ ├── run-strip-remove-keep.sh
│ │ ├── run-strip-strmerge.sh
│ │ ├── run-strip-test-many.sh
│ │ ├── run-strip-test.sh
│ │ ├── run-strip-test10.sh
│ │ ├── run-strip-test11.sh
│ │ ├── run-strip-test12.sh
│ │ ├── run-strip-test2.sh
│ │ ├── run-strip-test3.sh
│ │ ├── run-strip-test4.sh
│ │ ├── run-strip-test5.sh
│ │ ├── run-strip-test6.sh
│ │ ├── run-strip-test7.sh
│ │ ├── run-strip-test8.sh
│ │ ├── run-strip-test9.sh
│ │ ├── run-strip-version.sh
│ │ ├── run-strptr.sh
│ │ ├── run-test-archive64.sh
│ │ ├── run-test-flag-nobits.sh
│ │ ├── run-typeiter-many.sh
│ │ ├── run-typeiter.sh
│ │ ├── run-unit-info.sh
│ │ ├── run-unstrip-M.sh
│ │ ├── run-unstrip-n.sh
│ │ ├── run-unstrip-test.sh
│ │ ├── run-unstrip-test2.sh
│ │ ├── run-unstrip-test3.sh
│ │ ├── run-unstrip-test4.sh
│ │ ├── run-varlocs-self.sh
│ │ ├── run-varlocs.sh
│ │ ├── run-zstrptr.sh
│ │ ├── saridx.c
│ │ ├── scnnames.c
│ │ ├── sectiondump.c
│ │ ├── show-abbrev.c
│ │ ├── show-die-info.c
│ │ ├── showptable.c
│ │ ├── splitdwarf4-not-split4.dwo.bz2
│ │ ├── strptr.c
│ │ ├── system-elf-libelf-test.c
│ │ ├── test-core-lib.so.bz2
│ │ ├── test-core.core.bz2
│ │ ├── test-core.exec.bz2
│ │ ├── test-elf_cntl_gelf_getshdr.c
│ │ ├── test-flag-nobits.c
│ │ ├── test-nlist.c
│ │ ├── test-offset-loop.alt.bz2
│ │ ├── test-offset-loop.bz2
│ │ ├── test-subr.sh
│ │ ├── test-wrapper.sh
│ │ ├── testarchive64.a.bz2
│ │ ├── testcore-rtlib-ppc.bz2
│ │ ├── testcore-rtlib.bz2
│ │ ├── testfile-ada-variant.bz2
│ │ ├── testfile-addrx_constx-4.bz2
│ │ ├── testfile-addrx_constx-5.bz2
│ │ ├── testfile-annobingroup-i386.o.bz2
│ │ ├── testfile-annobingroup-x86_64.o.bz2
│ │ ├── testfile-annobingroup.o.bz2
│ │ ├── testfile-backtrace-demangle.bz2
│ │ ├── testfile-backtrace-demangle.cc
│ │ ├── testfile-backtrace-demangle.core.bz2
│ │ ├── testfile-bpf-dis1.expect.bz2
│ │ ├── testfile-bpf-dis1.o.bz2
│ │ ├── testfile-bpf-reloc.expect.bz2
│ │ ├── testfile-bpf-reloc.o.bz2
│ │ ├── testfile-const-values.debug.bz2
│ │ ├── testfile-debug-rel-g.o.bz2
│ │ ├── testfile-debug-rel-ppc64-g.o.bz2
│ │ ├── testfile-debug-rel-ppc64-z.o.bz2
│ │ ├── testfile-debug-rel-ppc64.o.bz2
│ │ ├── testfile-debug-rel-z.o.bz2
│ │ ├── testfile-debug-rel.o.bz2
│ │ ├── testfile-debug-types.bz2
│ │ ├── testfile-debug.bz2
│ │ ├── testfile-dwarf-4.bz2
│ │ ├── testfile-dwarf-45.source
│ │ ├── testfile-dwarf-5.bz2
│ │ ├── testfile-dwfl-report-elf-align-shlib.so.bz2
│ │ ├── testfile-dwzstr.bz2
│ │ ├── testfile-dwzstr.multi.bz2
│ │ ├── testfile-gnu-property-note.bz2
│ │ ├── testfile-gnu-property-note.o.bz2
│ │ ├── testfile-hello4.dwo.bz2
│ │ ├── testfile-hello5.dwo.bz2
│ │ ├── testfile-info-link.bz2
│ │ ├── testfile-info-link.debuginfo.bz2
│ │ ├── testfile-info-link.stripped.bz2
│ │ ├── testfile-inlines.bz2
│ │ ├── testfile-lex-inlines.bz2
│ │ ├── testfile-m68k-core.bz2
│ │ ├── testfile-m68k-s.bz2
│ │ ├── testfile-m68k.bz2
│ │ ├── testfile-macinfo.bz2
│ │ ├── testfile-macros-0xff.bz2
│ │ ├── testfile-macros.bz2
│ │ ├── testfile-nobitsalign.bz2
│ │ ├── testfile-nobitsalign.strip.bz2
│ │ ├── testfile-nolfs.bz2
│ │ ├── testfile-only-debug-line.bz2
│ │ ├── testfile-ppc64-min-instr.bz2
│ │ ├── testfile-ranges-hello.dwo.bz2
│ │ ├── testfile-ranges-hello5.dwo.bz2
│ │ ├── testfile-ranges-world.dwo.bz2
│ │ ├── testfile-ranges-world5.dwo.bz2
│ │ ├── testfile-riscv64-core.bz2
│ │ ├── testfile-riscv64-s.bz2
│ │ ├── testfile-riscv64.bz2
│ │ ├── testfile-s390x-hash-both.bz2
│ │ ├── testfile-sizes1.o.bz2
│ │ ├── testfile-sizes2.o.bz2
│ │ ├── testfile-sizes3.o.bz2
│ │ ├── testfile-sizes4.o.bz2
│ │ ├── testfile-sizes4.s
│ │ ├── testfile-splitdwarf-4.bz2
│ │ ├── testfile-splitdwarf-5.bz2
│ │ ├── testfile-splitdwarf4-not-split4.debug.bz2
│ │ ├── testfile-stridex.bz2
│ │ ├── testfile-strtab.bz2
│ │ ├── testfile-strtab.debuginfo.bz2
│ │ ├── testfile-strtab.stripped.bz2
│ │ ├── testfile-version.bz2
│ │ ├── testfile-world4.dwo.bz2
│ │ ├── testfile-world5.dwo.bz2
│ │ ├── testfile-x32-core.bz2
│ │ ├── testfile-x32-d.bz2
│ │ ├── testfile-x32-debug.bz2
│ │ ├── testfile-x32-s.bz2
│ │ ├── testfile-x32.bz2
│ │ ├── testfile-zdebug.bz2
│ │ ├── testfile-zgabi32.bz2
│ │ ├── testfile-zgabi32be.bz2
│ │ ├── testfile-zgabi64.bz2
│ │ ├── testfile-zgabi64be.bz2
│ │ ├── testfile-zgnu32.bz2
│ │ ├── testfile-zgnu32be.bz2
│ │ ├── testfile-zgnu64.bz2
│ │ ├── testfile-zgnu64be.bz2
│ │ ├── testfile.bz2
│ │ ├── testfile10.bz2
│ │ ├── testfile11-debugframe.bz2
│ │ ├── testfile11.bz2
│ │ ├── testfile12-debugframe.bz2
│ │ ├── testfile12.bz2
│ │ ├── testfile13.bz2
│ │ ├── testfile14.bz2
│ │ ├── testfile15.bz2
│ │ ├── testfile15.debug.bz2
│ │ ├── testfile16.bz2
│ │ ├── testfile16.debug.bz2
│ │ ├── testfile17.bz2
│ │ ├── testfile17.debug.bz2
│ │ ├── testfile18.bz2
│ │ ├── testfile19.bz2
│ │ ├── testfile19.index.bz2
│ │ ├── testfile2.bz2
│ │ ├── testfile20.bz2
│ │ ├── testfile20.index.bz2
│ │ ├── testfile21.bz2
│ │ ├── testfile21.index.bz2
│ │ ├── testfile22.bz2
│ │ ├── testfile23.bz2
│ │ ├── testfile24.bz2
│ │ ├── testfile25.bz2
│ │ ├── testfile26.bz2
│ │ ├── testfile27.bz2
│ │ ├── testfile28.bz2
│ │ ├── testfile28.rdwr.bz2
│ │ ├── testfile29.bz2
│ │ ├── testfile29.rdwr.bz2
│ │ ├── testfile3.bz2
│ │ ├── testfile30.bz2
│ │ ├── testfile31.bz2
│ │ ├── testfile32.bz2
│ │ ├── testfile33.bz2
│ │ ├── testfile34.bz2
│ │ ├── testfile35.bz2
│ │ ├── testfile35.debug.bz2
│ │ ├── testfile36.bz2
│ │ ├── testfile36.debug.bz2
│ │ ├── testfile37.bz2
│ │ ├── testfile37.debug.bz2
│ │ ├── testfile38.bz2
│ │ ├── testfile39.bz2
│ │ ├── testfile4.bz2
│ │ ├── testfile40.bz2
│ │ ├── testfile40.debug.bz2
│ │ ├── testfile41.bz2
│ │ ├── testfile42.bz2
│ │ ├── testfile42_noshdrs.bz2
│ │ ├── testfile43.bz2
│ │ ├── testfile44.S.bz2
│ │ ├── testfile44.expect.bz2
│ │ ├── testfile45.S.bz2
│ │ ├── testfile45.expect.bz2
│ │ ├── testfile46.bz2
│ │ ├── testfile47.bz2
│ │ ├── testfile48.bz2
│ │ ├── testfile48.debug.bz2
│ │ ├── testfile49.bz2
│ │ ├── testfile5.bz2
│ │ ├── testfile50.bz2
│ │ ├── testfile51.bz2
│ │ ├── testfile52-32.noshdrs.so.bz2
│ │ ├── testfile52-32.prelink.so.bz2
│ │ ├── testfile52-32.so.bz2
│ │ ├── testfile52-32.so.debug.bz2
│ │ ├── testfile52-64.noshdrs.so.bz2
│ │ ├── testfile52-64.prelink.so.bz2
│ │ ├── testfile52-64.so.bz2
│ │ ├── testfile52-64.so.debug.bz2
│ │ ├── testfile53-32.bz2
│ │ ├── testfile53-32.debug.bz2
│ │ ├── testfile53-32.prelink.bz2
│ │ ├── testfile53-64.bz2
│ │ ├── testfile53-64.debug.bz2
│ │ ├── testfile53-64.prelink.bz2
│ │ ├── testfile54-32.noshdrs.so.bz2
│ │ ├── testfile54-32.prelink.so.bz2
│ │ ├── testfile54-32.so.bz2
│ │ ├── testfile54-32.so.debug.bz2
│ │ ├── testfile54-64.noshdrs.so.bz2
│ │ ├── testfile54-64.prelink.so.bz2
│ │ ├── testfile54-64.so.bz2
│ │ ├── testfile54-64.so.debug.bz2
│ │ ├── testfile55-32.bz2
│ │ ├── testfile55-32.debug.bz2
│ │ ├── testfile55-32.prelink.bz2
│ │ ├── testfile55-64.bz2
│ │ ├── testfile55-64.debug.bz2
│ │ ├── testfile55-64.prelink.bz2
│ │ ├── testfile56.bz2
│ │ ├── testfile57.bz2
│ │ ├── testfile58.bz2
│ │ ├── testfile59.bz2
│ │ ├── testfile6.bz2
│ │ ├── testfile60.bz2
│ │ ├── testfile61.bz2
│ │ ├── testfile62.bz2
│ │ ├── testfile63.bz2
│ │ ├── testfile64.bz2
│ │ ├── testfile65.bz2
│ │ ├── testfile66.bz2
│ │ ├── testfile66.core.bz2
│ │ ├── testfile67.bz2
│ │ ├── testfile68.bz2
│ │ ├── testfile69.core.bz2
│ │ ├── testfile69.so.bz2
│ │ ├── testfile7.bz2
│ │ ├── testfile70.core.bz2
│ │ ├── testfile70.exec.bz2
│ │ ├── testfile71.bz2
│ │ ├── testfile8.bz2
│ │ ├── testfile9.bz2
│ │ ├── testfile_aarch64_core.bz2
│ │ ├── testfile_class_func.bz2
│ │ ├── testfile_const_type.bz2
│ │ ├── testfile_const_type.c
│ │ ├── testfile_entry_value.bz2
│ │ ├── testfile_entry_value.c
│ │ ├── testfile_gnu_props.32be.o.bz2
│ │ ├── testfile_gnu_props.32le.o.bz2
│ │ ├── testfile_gnu_props.64be.o.bz2
│ │ ├── testfile_gnu_props.64le.o.bz2
│ │ ├── testfile_i686_core.bz2
│ │ ├── testfile_implicit_pointer.bz2
│ │ ├── testfile_implicit_pointer.c
│ │ ├── testfile_implicit_value.bz2
│ │ ├── testfile_implicit_value.c
│ │ ├── testfile_low_high_pc.bz2
│ │ ├── testfile_multi.dwz.bz2
│ │ ├── testfile_multi_main.bz2
│ │ ├── testfile_nested_funcs.bz2
│ │ ├── testfile_parameter_ref.bz2
│ │ ├── testfile_parameter_ref.c
│ │ ├── testfileaarch64-debugframe.bz2
│ │ ├── testfileaarch64.bz2
│ │ ├── testfilearm-debugframe.bz2
│ │ ├── testfilearm.bz2
│ │ ├── testfilebasmin.bz2
│ │ ├── testfilebaxmin.bz2
│ │ ├── testfilebazdbg.bz2
│ │ ├── testfilebazdbg.debug.bz2
│ │ ├── testfilebazdbg_pl.bz2
│ │ ├── testfilebazdbg_plr.bz2
│ │ ├── testfilebazdbgppc64.bz2
│ │ ├── testfilebazdbgppc64.debug.bz2
│ │ ├── testfilebazdbgppc64_pl.bz2
│ │ ├── testfilebazdbgppc64_plr.bz2
│ │ ├── testfilebazdyn.bz2
│ │ ├── testfilebazdynppc64.bz2
│ │ ├── testfilebazmdb.bz2
│ │ ├── testfilebazmdbppc64.bz2
│ │ ├── testfilebazmin.bz2
│ │ ├── testfilebazmin_pl.bz2
│ │ ├── testfilebazmin_plr.bz2
│ │ ├── testfilebazminppc64.bz2
│ │ ├── testfilebazminppc64_pl.bz2
│ │ ├── testfilebazminppc64_plr.bz2
│ │ ├── testfilebaztab.bz2
│ │ ├── testfilebaztabppc64.bz2
│ │ ├── testfiledwarfinlines.bz2
│ │ ├── testfiledwarfinlines.core.bz2
│ │ ├── testfilefoobarbaz.bz2
│ │ ├── testfilegdbindex5.bz2
│ │ ├── testfilegdbindex7.bz2
│ │ ├── testfileloc.bz2
│ │ ├── testfilemacro.bz2
│ │ ├── testfilenolines.bz2
│ │ ├── testfileppc32-debugframe.bz2
│ │ ├── testfileppc32.bz2
│ │ ├── testfileppc32attrs.o.bz2
│ │ ├── testfileppc64-debugframe.bz2
│ │ ├── testfileppc64.bz2
│ │ ├── testfileppc64attrs.o.bz2
│ │ ├── testfileranges4.debug.bz2
│ │ ├── testfileranges5.debug.bz2
│ │ ├── testfiles390.bz2
│ │ ├── testfiles390x.bz2
│ │ ├── testfilesparc64attrs.o.bz2
│ │ ├── testfilesplitranges4.debug.bz2
│ │ ├── testfilesplitranges5.debug.bz2
│ │ ├── testlib_dynseg.so.bz2
│ │ ├── typeiter.c
│ │ ├── typeiter2.c
│ │ ├── unit-info.c
│ │ ├── update1.c
│ │ ├── update2.c
│ │ ├── update3.c
│ │ ├── update4.c
│ │ ├── varlocs.c
│ │ ├── vdsosyms.c
│ │ ├── vendorelf.c
│ │ └── zstrptr.c
│ └── version.h
├── tracers-libstapsdt-sys/
│ ├── Cargo.toml
│ ├── LICENSE
│ ├── bindgen.sh
│ ├── build.rs
│ └── src/
│ ├── lib.h
│ ├── lib.rs
│ ├── libstapsdt.rs
│ └── test-libstapsdt.c
├── tracers-macros/
│ ├── Cargo.toml
│ └── src/
│ └── lib.rs
└── tracers-macros-hack/
├── Cargo.toml
└── src/
└── lib.rs
Showing preview only (466K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (6077 symbols across 662 files)
FILE: examples/simple/build.rs
function main (line 3) | fn main() {
FILE: examples/simple/src/main.rs
type SimpleProbes (line 9) | trait SimpleProbes {
method hello (line 10) | fn hello(who: &str);
method greeting (line 11) | fn greeting(greeting: &str, name: &str);
method optional_greeting (line 12) | fn optional_greeting(greeting: &str, name: &Option<&str>);
function main (line 15) | fn main() {
FILE: tracers-codegen/src/argtypes.rs
function from_syn_type (line 77) | pub(crate) fn from_syn_type(ty: &syn::Type) -> Option<ArgTypeInfo> {
type ArgTypeInfo (line 94) | pub(crate) struct ArgTypeInfo {
method new (line 103) | pub fn new<T: ProbeArgType<T>>() -> ArgTypeInfo {
method get_c_type_enum (line 113) | pub fn get_c_type_enum(&self) -> CType {
method get_c_type_str (line 119) | pub fn get_c_type_str(&self) -> &str {
method get_rust_type_str (line 134) | pub fn get_rust_type_str(&self) -> &str {
function test_type_support (line 197) | fn test_type_support() {
function test_support_for_all_test_traits (line 227) | fn test_support_for_all_test_traits() {
FILE: tracers-codegen/src/build_rs.rs
type FeatureFlags (line 21) | struct FeatureFlags {
method from_env (line 35) | pub fn from_env() -> TracersResult<FeatureFlags> {
method new (line 48) | pub fn new(
method enable_tracing (line 84) | pub fn enable_tracing(&self) -> bool {
method enable_dynamic (line 88) | pub fn enable_dynamic(&self) -> bool {
method enable_static (line 92) | pub fn enable_static(&self) -> bool {
method force_dyn_stap (line 96) | pub fn force_dyn_stap(&self) -> bool {
method force_dyn_noop (line 101) | pub fn force_dyn_noop(&self) -> bool {
method force_static_stap (line 106) | pub fn force_static_stap(&self) -> bool {
method force_static_lttng (line 111) | pub fn force_static_lttng(&self) -> bool {
method is_feature_enabled (line 116) | fn is_feature_enabled(name: &str) -> bool {
type BuildInfo (line 128) | pub(crate) struct BuildInfo {
method new (line 134) | pub fn new(package_name: String, implementation: TracingImplementation...
method load (line 141) | pub fn load() -> TracersResult<BuildInfo> {
method save (line 152) | pub fn save(&self) -> TracersResult<PathBuf> {
method get_build_path (line 172) | fn get_build_path() -> TracersResult<PathBuf> {
function build (line 243) | pub fn build() {
function build_internal (line 259) | fn build_internal<OUT: Write>(out: &mut OUT) -> TracersResult<()> {
function tracers_build (line 277) | pub fn tracers_build() {
function tracers_build_internal (line 295) | fn tracers_build_internal<OUT: Write>(out: &mut OUT, features: FeatureFl...
function select_implementation (line 346) | fn select_implementation(features: &FeatureFlags) -> TracersResult<Traci...
function generate_native_code (line 390) | fn generate_native_code(out: &mut dyn Write) -> TracersResult<()> {
function tracers_build_panics_invalid_features (line 450) | fn tracers_build_panics_invalid_features() {
function build_rs_workflow_tests (line 463) | fn build_rs_workflow_tests() {
FILE: tracers-codegen/src/cache.rs
function cache_file_computation (line 18) | pub(crate) fn cache_file_computation<
function cache_object_computation (line 65) | pub(crate) fn cache_object_computation<
function get_cached_object_computation (line 92) | pub(crate) fn get_cached_object_computation<T: Serialize + DeserializeOw...
function cache_generated_file (line 114) | pub(crate) fn cache_generated_file<F: FnOnce(PathBuf) -> Fallible<PathBu...
function get_cache_path (line 140) | pub(crate) fn get_cache_path(root: &Path) -> PathBuf {
function load_cached_results (line 151) | fn load_cached_results<T: Serialize + DeserializeOwned>(results_path: &P...
function save_results (line 158) | fn save_results<T: Serialize + DeserializeOwned>(results_path: &Path, re...
function cached_results_path (line 187) | fn cached_results_path(input_path: &Path, key: &str, hash: HashCode) -> ...
type TestResult (line 205) | struct TestResult {
function caches_file_results (line 210) | fn caches_file_results() {
function caches_objects_results (line 285) | fn caches_objects_results() {
function caches_generated_data (line 350) | fn caches_generated_data() {
FILE: tracers-codegen/src/cargo.rs
function get_targets (line 11) | pub(crate) fn get_targets(manifest_path: &Path, package_name: &str) -> F...
function gets_correct_targets (line 35) | fn gets_correct_targets() {
FILE: tracers-codegen/src/deps.rs
type SourceDependency (line 12) | pub(crate) enum SourceDependency {
function get_dependencies (line 18) | pub(crate) fn get_dependencies(contents: &syn::File) -> Vec<SourceDepend...
function resolve_dependency (line 28) | pub(crate) fn resolve_dependency(source_path: &Path, dep: &SourceDepende...
function find_module (line 41) | fn find_module(source_path: &Path, module_name: &str) -> Fallible<PathBu...
type Visitor (line 61) | struct Visitor {
method new (line 66) | fn new() -> Visitor {
method visit_item_mod (line 72) | fn visit_item_mod(&mut self, i: &'ast syn::ItemMod) {
function parse (line 113) | fn parse(source_path: &Path) -> Fallible<syn::File> {
function find_sources (line 121) | fn find_sources(entrypoint: &Path) -> (Vec<PathBuf>, Vec<(PathBuf, Error...
function test_case (line 149) | fn test_case() {
FILE: tracers-codegen/src/error.rs
type TracersError (line 18) | pub enum TracersError {
method eq (line 104) | fn eq(&self, other: &TracersError) -> bool {
method invalid_provider (line 112) | pub fn invalid_provider<T: ToTokens>(message: impl AsRef<str>, element...
method syn_error (line 125) | pub fn syn_error(message: impl AsRef<str>, e: syn::Error) -> TracersEr...
method syn_like_error (line 146) | pub fn syn_like_error<T: ToTokens, U: Display>(message: U, tokens: T) ...
method darling_error (line 152) | pub fn darling_error(e: DarlingError) -> TracersError {
method invalid_call_expression (line 161) | pub fn invalid_call_expression<T: ToTokens>(
method other_error (line 173) | pub fn other_error<D: Display + Send + Sync + 'static>(e: failure::Con...
method missing_call_in_build_rs (line 180) | pub fn missing_call_in_build_rs() -> TracersError {
method build_info_read_error (line 184) | pub fn build_info_read_error(build_info_path: PathBuf, e: Error) -> Tr...
method build_info_write_error (line 195) | pub fn build_info_write_error(build_info_path: PathBuf, e: Error) -> T...
method provider_trait_not_processed_error (line 206) | pub fn provider_trait_not_processed_error<T: AsRef<str>, E: Into<Error...
method code_generation_error (line 219) | pub fn code_generation_error<S: AsRef<str>>(message: S) -> TracersError {
method native_code_generation_error (line 225) | pub fn native_code_generation_error<S: AsRef<str>, E: Into<Error> + Di...
method into_syn_error (line 237) | pub fn into_syn_error(self) -> syn::Error {
method into_compiler_error (line 252) | pub fn into_compiler_error(self) -> TokenStream {
method new_syn_error (line 270) | fn new_syn_error<T: ToTokens, U: Display>(message: U, tokens: T) -> Er...
method wrap_syn_error (line 274) | fn wrap_syn_error(e: syn::Error) -> Error {
method error_as_syn_error (line 280) | fn error_as_syn_error(e: Error) -> syn::Error {
method wrap_error (line 285) | fn wrap_error(e: impl std::error::Error + Sync + Send + 'static) -> Er...
method error_string (line 291) | fn error_string(e: &Error) -> String {
method fail_string (line 297) | fn fail_string(f: &dyn Fail) -> String {
method from (line 306) | fn from(failure: failure::Context<D>) -> TracersError {
method fmt (line 83) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
type TracersResult (line 311) | pub type TracersResult<T> = std::result::Result<T, TracersError>;
FILE: tracers-codegen/src/gen/common/mod.rs
type ProviderTraitGeneratorBase (line 17) | pub(super) trait ProviderTraitGeneratorBase {
method spec (line 18) | fn spec(&self) -> &ProviderSpecification;
method build_info (line 20) | fn build_info(&self) -> &BuildInfo;
method generate_trait_comment (line 26) | fn generate_trait_comment(&self) -> TokenStream {
method generate_try_init_decl (line 63) | fn generate_try_init_decl(&self) -> TokenStream {
method get_provider_impl_mod_name (line 126) | fn get_provider_impl_mod_name(&self) -> syn::Ident {
method get_provider_impl_struct_type_name (line 135) | fn get_provider_impl_struct_type_name(&self) -> syn::Ident {
type ProbeGeneratorBase (line 142) | pub(super) trait ProbeGeneratorBase {
method spec (line 143) | fn spec(&self) -> &ProbeSpecification;
method generate_probe_deprecation_attribute (line 147) | fn generate_probe_deprecation_attribute(
method generate_probe_doc_comment (line 163) | fn generate_probe_doc_comment(&self, provider: &ProviderSpecification)...
method args_lifetime_parameters (line 216) | fn args_lifetime_parameters(&self) -> Vec<syn::Lifetime> {
method args_as_tuple_value (line 231) | fn args_as_tuple_value(&self) -> TokenStream {
method args_as_tuple_type_without_lifetimes (line 240) | fn args_as_tuple_type_without_lifetimes(&self) -> TokenStream {
method args_as_tuple_type_with_lifetimes (line 250) | fn args_as_tuple_type_with_lifetimes(&self) -> TokenStream {
function get_provider_impl_mod_name (line 264) | pub(super) fn get_provider_impl_mod_name(trait_ident: &syn::Ident) -> St...
function generate_tuple (line 273) | pub(super) fn generate_tuple<T: ToTokens, I: IntoIterator<Item = T>>(ele...
function generate_init_provider (line 287) | pub(super) fn generate_init_provider(
function generate_multiline_comments (line 306) | fn generate_multiline_comments(comment: &str) -> TokenStream {
FILE: tracers-codegen/src/gen/dynamic/mod.rs
type DynamicGenerator (line 25) | pub(crate) struct DynamicGenerator {
method new (line 30) | pub fn new(build_info: BuildInfo) -> DynamicGenerator {
method handle_provider_trait (line 36) | fn handle_provider_trait(&self, provider: ProviderSpecification) -> Trac...
method handle_probe_call (line 42) | fn handle_probe_call(&self, call: ProbeCallSpecification) -> TracersResu...
method handle_init_provider (line 46) | fn handle_init_provider(&self, init: ProviderInitSpecification) -> Trace...
method generate_native_code (line 50) | fn generate_native_code(
FILE: tracers-codegen/src/gen/dynamic/probe_call.rs
function generate_probe_call (line 36) | pub(super) fn generate_probe_call(call: ProbeCallSpecification) -> Trace...
FILE: tracers-codegen/src/gen/dynamic/provider_trait.rs
type ProviderTraitGenerator (line 15) | pub(super) struct ProviderTraitGenerator<'bi> {
method spec (line 22) | fn spec(&self) -> &ProviderSpecification {
method build_info (line 26) | fn build_info(&self) -> &BuildInfo {
function new (line 32) | pub fn new(
function generate (line 50) | pub fn generate(&self) -> TracersResult<TokenStream> {
function generate_tracer_struct (line 69) | fn generate_tracer_struct(&self) -> TracersResult<TokenStream> {
function generate_impl_mod (line 141) | fn generate_impl_mod(&self) -> TokenStream {
function generate_define_provider_call (line 239) | fn generate_define_provider_call(&self) -> TokenStream {
function generate_provider_struct_type_params (line 274) | fn generate_provider_struct_type_params(&self) -> TokenStream {
function get_provider_impl_struct_var_name (line 291) | fn get_provider_impl_struct_var_name(&self) -> syn::Ident {
function get_provider_instance_var_name (line 300) | fn get_provider_instance_var_name(&self) -> syn::Ident {
type ProbeGenerator (line 308) | pub(super) struct ProbeGenerator {
method new (line 319) | pub fn new(spec: ProbeSpecification) -> ProbeGenerator {
method probe_var_name (line 325) | pub(crate) fn probe_var_name(&self) -> &syn::Ident {
method generate_trait_methods (line 346) | pub fn generate_trait_methods(
method generate_add_probe_call (line 450) | pub(crate) fn generate_add_probe_call(&self, builder: &syn::Ident) -> ...
method generate_provider_probe_type (line 471) | pub(crate) fn generate_provider_probe_type(&self) -> TokenStream {
method generate_struct_member_declaration (line 489) | pub(crate) fn generate_struct_member_declaration(&self) -> TokenStream {
method generate_struct_member_initialization (line 515) | pub(crate) fn generate_struct_member_initialization(
method spec (line 313) | fn spec(&self) -> &ProbeSpecification {
function generate_works_on_valid_traits (line 543) | fn generate_works_on_valid_traits() {
FILE: tracers-codegen/src/gen/mod.rs
type NativeLib (line 32) | pub(crate) enum NativeLib {
type CodeGenerator (line 59) | pub(crate) trait CodeGenerator {
method handle_provider_trait (line 62) | fn handle_provider_trait(&self, provider: ProviderSpecification) -> Tr...
method handle_probe_call (line 65) | fn handle_probe_call(&self, call: ProbeCallSpecification) -> TracersRe...
method handle_init_provider (line 70) | fn handle_init_provider(&self, init: ProviderInitSpecification) -> Tra...
method generate_native_code (line 79) | fn generate_native_code(
function code_generator (line 91) | pub(crate) fn code_generator() -> TracersResult<Box<dyn CodeGenerator>> {
FILE: tracers-codegen/src/gen/static/c.rs
function generate_provider_funcs (line 18) | pub(crate) fn generate_provider_funcs(
type SourceFile (line 34) | struct SourceFile<'a> {
function from_provider_spec (line 45) | fn from_provider_spec<'b: 'a>(provider: &'b ProviderSpecification) -> So...
type Probe (line 64) | struct Probe<'a> {
function from_probe_spec (line 70) | fn from_probe_spec<'b: 'a>(
type ProbeArg (line 87) | struct ProbeArg {
method new (line 93) | fn new(name: String, typ: String) -> ProbeArg {
function generate_source_file (line 98) | fn generate_source_file(provider: &ProviderSpecification, abs_path: Path...
FILE: tracers-codegen/src/gen/static/mod.rs
type StaticGenerator (line 35) | pub(crate) struct StaticGenerator {
method new (line 40) | pub fn new(build_info: BuildInfo) -> StaticGenerator {
method handle_provider_trait (line 46) | fn handle_provider_trait(&self, provider: ProviderSpecification) -> Trac...
method handle_probe_call (line 52) | fn handle_probe_call(&self, call: ProbeCallSpecification) -> TracersResu...
method handle_init_provider (line 56) | fn handle_init_provider(&self, init: ProviderInitSpecification) -> Trace...
method generate_native_code (line 60) | fn generate_native_code(
FILE: tracers-codegen/src/gen/static/native_code/mod.rs
type ProcessedFile (line 21) | pub(crate) struct ProcessedFile {
type ProcessedProviderTrait (line 29) | pub(crate) struct ProcessedProviderTrait {
type NativeCodeGenerator (line 33) | trait NativeCodeGenerator {
method generate_native_lib (line 36) | fn generate_native_lib(&self) -> TracersResult<Vec<NativeLib>>;
method out_dir (line 38) | fn out_dir(&self) -> &Path;
method build_dir (line 40) | fn build_dir(&self) -> PathBuf {
method output_dir (line 44) | fn output_dir(&self) -> PathBuf {
constant PROCESSED_PROVIDER_KEY (line 49) | const PROCESSED_PROVIDER_KEY: &str = "processed_provider";
function get_processed_provider_info (line 60) | pub(crate) fn get_processed_provider_info(
function generate_native_code (line 74) | pub(super) fn generate_native_code(
function process_file (line 107) | fn process_file(
function process_provider (line 200) | fn process_provider(
function create_native_code_generator (line 253) | fn create_native_code_generator(
function caches_results (line 281) | fn caches_results() {
function generates_processed_provider_trait (line 364) | fn generates_processed_provider_trait() {
FILE: tracers-codegen/src/gen/static/native_code/target/lttng.rs
type LttngUstLibInfo (line 26) | struct LttngUstLibInfo {
method get (line 34) | fn get(cache_dir: &Path) -> TracersResult<Self> {
method into_native_libs (line 64) | fn into_native_libs(self) -> Vec<NativeLib> {
type NativeProviderWrapperTemplate (line 90) | struct NativeProviderWrapperTemplate<'a> {
function from_provider_spec (line 95) | fn from_provider_spec<'b: 'a>(
function get_probe_args (line 101) | fn get_probe_args<'args>(
type NativeProviderTemplate (line 114) | struct NativeProviderTemplate<'a> {
function from_provider_spec (line 119) | fn from_provider_spec<'b: 'a>(
function get_probe_arg_ctf_macro (line 137) | fn get_probe_arg_ctf_macro(arg: &ProbeArgSpecification) -> Option<String> {
function get_probe_output_fields (line 164) | fn get_probe_output_fields(&self, probe: &ProbeSpecification) -> String {
function get_probe_args (line 175) | fn get_probe_args<'args>(
function get_probe_args (line 185) | fn get_probe_args<'args>(probe: &'args ProbeSpecification) -> Vec<&'args...
type LttngNativeCodeGenerator (line 189) | pub(crate) struct LttngNativeCodeGenerator {
method new (line 195) | pub fn new(out_dir: &Path, provider: ProviderSpecification) -> LttngNa...
method generate_native_lib (line 204) | fn generate_native_lib(&self) -> TracersResult<Vec<NativeLib>> {
method out_dir (line 360) | fn out_dir(&self) -> &Path {
FILE: tracers-codegen/src/gen/static/native_code/target/stap.rs
type NativeProviderWrapperTemplate (line 16) | struct NativeProviderWrapperTemplate<'a> {
function from_provider_spec (line 21) | fn from_provider_spec<'b: 'a>(
type StapNativeCodeGenerator (line 28) | pub(crate) struct StapNativeCodeGenerator {
method new (line 34) | pub fn new(out_dir: &Path, provider: ProviderSpecification) -> StapNat...
method generate_native_lib (line 43) | fn generate_native_lib(&self) -> TracersResult<Vec<NativeLib>> {
method out_dir (line 105) | fn out_dir(&self) -> &Path {
FILE: tracers-codegen/src/gen/static/probe_call.rs
function generate_probe_call (line 14) | pub(crate) fn generate_probe_call(
FILE: tracers-codegen/src/gen/static/provider_trait.rs
type ProviderTraitGenerator (line 21) | pub(crate) struct ProviderTraitGenerator<'bi> {
method spec (line 29) | fn spec(&self) -> &ProviderSpecification {
method build_info (line 33) | fn build_info(&self) -> &BuildInfo {
function new (line 39) | pub fn new(
function generate (line 85) | pub fn generate(&self) -> TracersResult<TokenStream> {
function generate_tracer_struct (line 105) | fn generate_tracer_struct(&self) -> TracersResult<TokenStream> {
function generate_impl_mod (line 159) | fn generate_impl_mod(&self) -> TokenStream {
type ProbeGenerator (line 268) | pub(super) struct ProbeGenerator {
method new (line 279) | pub fn new(spec: ProbeSpecification) -> ProbeGenerator {
method generate_trait_methods (line 283) | pub fn generate_trait_methods(
method generate_probe_method_body (line 328) | fn generate_probe_method_body(
method generate_native_declaration (line 416) | fn generate_native_declaration(&self, provider: &ProviderTraitGenerato...
method generate_native_probe_func (line 429) | fn generate_native_probe_func(&self, provider: &ProviderTraitGenerator...
method generate_native_is_enabled (line 504) | fn generate_native_is_enabled(&self, provider: &ProviderTraitGenerator...
method generate_rust_is_enabled (line 570) | fn generate_rust_is_enabled(&self, provider: &ProviderTraitGenerator) ...
method generate_wrapper_func (line 601) | fn generate_wrapper_func(&self) -> TokenStream {
method spec (line 273) | fn spec(&self) -> &ProbeSpecification {
function generate_works_on_valid_traits (line 674) | fn generate_works_on_valid_traits() {
function falls_back_to_disabled_on_error (line 710) | fn falls_back_to_disabled_on_error() {
FILE: tracers-codegen/src/hashing.rs
type HashCode (line 14) | pub(crate) type HashCode = u64;
function hash_buf (line 16) | pub(crate) fn hash_buf(buf: &[u8]) -> HashCode {
function hash (line 20) | pub(crate) fn hash<T: Hash>(something: T) -> HashCode {
function add_hash_to_path (line 40) | pub(crate) fn add_hash_to_path(path: &Path, hash: HashCode) -> PathBuf {
function hash_equality (line 63) | fn hash_equality() {
function hash_inequality (line 68) | fn hash_inequality() {
function file_name_generation (line 73) | fn file_name_generation() {
FILE: tracers-codegen/src/lib.rs
type TracingType (line 32) | pub(crate) enum TracingType {
method is_enabled (line 42) | pub fn is_enabled(&self) -> bool {
type TracingTarget (line 49) | pub(crate) enum TracingTarget {
method is_enabled (line 61) | pub fn is_enabled(&self) -> bool {
method has_native_enabled_func (line 65) | pub fn has_native_enabled_func(&self) -> bool {
type TracingImplementation (line 75) | pub(crate) enum TracingImplementation {
method tracing_type (line 96) | pub fn tracing_type(&self) -> TracingType {
method tracing_target (line 100) | pub fn tracing_target(&self) -> TracingTarget {
method is_enabled (line 104) | pub fn is_enabled(&self) -> bool {
method is_dynamic (line 108) | pub fn is_dynamic(&self) -> bool {
method is_static (line 112) | pub fn is_static(&self) -> bool {
FILE: tracers-codegen/src/proc_macros.rs
function report_error (line 21) | pub fn report_error<T: quote::ToTokens, U: Display>(tokens: &T, message:...
function probe_impl (line 50) | pub fn probe_impl(tokens: TokenStream) -> TracersResult<TokenStream> {
function init_provider_impl (line 54) | pub fn init_provider_impl(tokens: TokenStream) -> TracersResult<TokenStr...
function tracer_impl (line 61) | pub fn tracer_impl(attr_tokens: TokenStream, tokens: TokenStream) -> Tra...
FILE: tracers-codegen/src/serde_helpers.rs
function serialize (line 15) | pub(crate) fn serialize<S: Serializer, T: ::syn::parse::Parse + quote::T...
function deserialize (line 25) | pub(crate) fn deserialize<
function serialize (line 47) | pub(crate) fn serialize<S: Serializer>(x: &TokenStream, s: S) -> Result<...
function deserialize (line 51) | pub(crate) fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Tok...
function serialize (line 66) | pub(crate) fn serialize<S: Serializer>(x: &::syn::PatIdent, s: S) -> Res...
function deserialize (line 73) | pub(crate) fn deserialize<'de, D: Deserializer<'de>>(
function serialize (line 97) | pub(crate) fn serialize<S: Serializer>(_x: &Span, s: S) -> Result<S::Ok,...
function deserialize (line 101) | pub(crate) fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Spa...
FILE: tracers-codegen/src/spec/init_provider.rs
type ProviderInitSpecification (line 26) | pub struct ProviderInitSpecification {
method fmt (line 31) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
method from_token_stream (line 45) | pub fn from_token_stream(tokens: TokenStream) -> TracersResult<Provide...
method from_path (line 52) | pub fn from_path(path: syn::Path) -> TracersResult<ProviderInitSpecifi...
FILE: tracers-codegen/src/spec/probe.rs
type ProbeSpecification (line 19) | pub(crate) struct ProbeSpecification {
method fmt (line 33) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
method from_method (line 57) | pub(crate) fn from_method(
method eq (line 128) | fn eq(&self, other: &ProbeSpecification) -> bool {
method eq (line 140) | fn eq(&self, other: &TestProbe) -> bool {
function trait_item (line 160) | pub(crate) fn trait_item() -> ItemTrait {
function valid_test_cases (line 166) | pub(crate) fn valid_test_cases() -> Vec<TraitItemMethod> {
function invalid_test_cases (line 177) | pub(crate) fn invalid_test_cases() -> Vec<TraitItemMethod> {
function works_with_valid_cases (line 194) | fn works_with_valid_cases() {
function works_with_invalid_cases (line 208) | fn works_with_invalid_cases() {
function decorates_args_with_lifetime_params (line 224) | fn decorates_args_with_lifetime_params() {
FILE: tracers-codegen/src/spec/probe_arg.rs
type ProbeArgSpecification (line 13) | pub(crate) struct ProbeArgSpecification {
method fmt (line 35) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
method from_fnarg (line 46) | pub fn from_fnarg(
method from_ident_type_pair (line 68) | pub fn from_ident_type_pair(
method name (line 97) | pub fn name(&self) -> &str {
method ident (line 101) | pub fn ident(&self) -> &syn::PatIdent {
method arg_type_info (line 105) | pub fn arg_type_info(&self) -> &ArgTypeInfo {
method syn_typ (line 109) | pub fn syn_typ(&self) -> &syn::Type {
method syn_typ_with_lifetimes (line 115) | pub fn syn_typ_with_lifetimes(&self) -> &syn::Type {
method lifetimes (line 122) | pub fn lifetimes(&self) -> Vec<syn::Lifetime> {
method add_lifetimes_to_syn_type (line 179) | fn add_lifetimes_to_syn_type(
method eq (line 218) | fn eq(&self, other: &ProbeArgSpecification) -> bool {
type TestCase (line 223) | struct TestCase {
method new (line 233) | fn new(
function get_test_cases (line 271) | fn get_test_cases() -> Vec<TestCase> {
function get_arg_from_test_case (line 282) | fn get_arg_from_test_case(case: &TestCase) -> TracersResult<ProbeArgSpec...
function parses_valid_test_cases (line 296) | fn parses_valid_test_cases() {
FILE: tracers-codegen/src/spec/probe_call.rs
type ProbeCallSpecification (line 37) | pub enum ProbeCallSpecification {
method from_token_stream (line 47) | pub fn from_token_stream(tokens: TokenStream) -> TracersResult<ProbeCa...
type ProbeCallDetails (line 64) | pub struct ProbeCallDetails {
method fmt (line 73) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
method from_call_expression (line 104) | pub fn from_call_expression(call: syn::Expr) -> TracersResult<ProbeCal...
function parses_all_test_cases (line 162) | fn parses_all_test_cases() {
FILE: tracers-codegen/src/spec/provider.rs
type TracerAttributeArgs (line 22) | pub(crate) struct TracerAttributeArgs {
method from_token_stream (line 62) | pub(crate) fn from_token_stream(attr: TokenStream) -> TracersResult<Se...
method from_attribute (line 67) | fn from_attribute(attr: syn::Attribute) -> TracersResult<Self> {
method parse (line 31) | fn parse(input: ParseStream) -> ParseResult<Self> {
type TracerAttribute (line 113) | pub(crate) struct TracerAttribute {
method from_attribute (line 118) | fn from_attribute(attr: syn::Attribute) -> TracersResult<Self> {
method parse (line 126) | fn parse(input: ParseStream) -> ParseResult<Self> {
type ProviderSpecification (line 143) | pub struct ProviderSpecification {
method fmt (line 155) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
method new (line 173) | fn new(
method from_token_stream (line 197) | pub(crate) fn from_token_stream(
method from_trait (line 208) | pub(crate) fn from_trait(
method provider_name_from_trait (line 217) | pub(crate) fn provider_name_from_trait(crate_name: &str, ident: &syn::...
method name (line 228) | pub(crate) fn name(&self) -> &str {
method name_with_hash (line 234) | pub(crate) fn name_with_hash(&self) -> String {
method hash (line 238) | pub(crate) fn hash(&self) -> HashCode {
method ident (line 242) | pub(crate) fn ident(&self) -> &syn::Ident {
method item_trait (line 246) | pub(crate) fn item_trait(&self) -> &syn::ItemTrait {
method token_stream (line 250) | pub(crate) fn token_stream(&self) -> &TokenStream {
method probes (line 254) | pub(crate) fn probes(&self) -> &Vec<ProbeSpecification> {
method separate_probes (line 262) | pub(crate) fn separate_probes(self) -> (ProviderSpecification, Vec<Pro...
method eq (line 380) | fn eq(&self, other: &ProviderSpecification) -> bool {
method eq (line 387) | fn eq(&self, other: &TestProviderTrait) -> bool {
function find_providers (line 285) | pub(crate) fn find_providers(crate_name: &str, ast: &syn::File) -> Vec<P...
function find_probes (line 345) | fn find_probes(item: &ItemTrait) -> TracersResult<Vec<ProbeSpecification...
function get_filtered_test_traits (line 397) | fn get_filtered_test_traits(with_errors: bool) -> Vec<TestProviderTrait> {
function find_providers_ignores_invalid_traits (line 402) | fn find_providers_ignores_invalid_traits() {
function find_providers_finds_valid_traits (line 420) | fn find_providers_finds_valid_traits() {
function find_probes_fails_with_invalid_traits (line 442) | fn find_probes_fails_with_invalid_traits() {
function find_probes_succeeds_with_valid_traits (line 469) | fn find_probes_succeeds_with_valid_traits() {
function found_providers_have_same_hash (line 483) | fn found_providers_have_same_hash() {
function provider_serde_test (line 534) | fn provider_serde_test() {
function parses_tracer_attributes_test (line 572) | fn parses_tracer_attributes_test() {
FILE: tracers-codegen/src/syn_helpers.rs
function transform_types (line 24) | pub(super) fn transform_types<F: FnMut(&syn::Type) -> TracersResult<syn:...
function recurse_tree (line 31) | fn recurse_tree<F: FnMut(&syn::Type) -> TracersResult<syn::Type>>(
function recurse_path (line 110) | fn recurse_path<F: FnMut(&syn::Type) -> TracersResult<syn::Type>>(
function add_suffix_to_ident (line 142) | pub(crate) fn add_suffix_to_ident(ident: &Ident, suffix: &str) -> Ident {
function convert_to_string (line 152) | pub(crate) fn convert_to_string<T: quote::ToTokens>(item: &T) -> String {
function get_test_data (line 165) | fn get_test_data() -> Vec<(syn::Type, syn::Type)> {
function identity_function (line 190) | fn identity_function() {
function add_lifetimes (line 204) | fn add_lifetimes() {
FILE: tracers-codegen/src/testdata.rs
type EnvVarsVec (line 28) | type EnvVarsVec = Vec<(String, String, Option<String>)>;
function unset_vars (line 36) | fn unset_vars(vars: &mut EnvVarsVec) {
type EnvVarsSetterGuard (line 51) | pub(crate) struct EnvVarsSetterGuard<'a> {
function unset (line 56) | fn unset(&mut self) {
method drop (line 62) | fn drop(&mut self) {
function with_env_vars (line 75) | pub(crate) fn with_env_vars<'a, K: AsRef<str>, V: AsRef<str>>(
type Target (line 120) | pub(crate) struct Target {
method new (line 137) | pub fn new(
type TestCrate (line 152) | pub(crate) struct TestCrate {
type TestProviderTrait (line 159) | pub(crate) struct TestProviderTrait {
method fmt (line 169) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
method new_invalid (line 191) | fn new_invalid(
method new_valid (line 208) | fn new_valid(
method get_attr_and_item_trait (line 225) | pub fn get_attr_and_item_trait(&self) -> (TracerAttribute, syn::ItemTr...
type TestProbe (line 234) | pub(crate) struct TestProbe {
method fmt (line 240) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
method new (line 252) | fn new(name: &'static str, args: Vec<(&'static str, &'static str, CTyp...
type TestProbeCall (line 268) | pub(crate) struct TestProbeCall {
function get_test_provider_traits (line 289) | pub(crate) fn get_test_provider_traits<F: FnMut(&TestProviderTrait) -> b...
function get_test_probe_calls (line 617) | pub(crate) fn get_test_probe_calls() -> Vec<TestProbeCall> {
FILE: tracers-codegen/templates/lttng/provider_wrapper.cpp
function _enabled (line 34) | _enabled() {
FILE: tracers-codegen/testdata/complexlib/build.rs
function main (line 1) | fn main() {
FILE: tracers-codegen/testdata/complexlib/src/bin/bin1.rs
function main (line 4) | fn main() {
FILE: tracers-codegen/testdata/complexlib/src/bin/bin2.rs
function main (line 4) | fn main() {
FILE: tracers-codegen/testdata/complexlib/src/lib.rs
type VariousProbes (line 4) | pub trait VariousProbes {
method bin1_start (line 5) | fn bin1_start();
method bin1_end (line 6) | fn bin1_end();
method bin2_start (line 8) | fn bin2_start();
method bin2_end (line 9) | fn bin2_end();
function it_works (line 15) | fn it_works() {
FILE: tracers-codegen/testdata/errors/src/main.rs
function main (line 3) | fn main() {
FILE: tracers-codegen/testdata/errors/tests/compile_errors.rs
function foo (line 3) | fn foo() { unimplemented!() }
FILE: tracers-codegen/testdata/simplebin/src/child_module.rs
function something (line 1) | pub fn something() {}
FILE: tracers-codegen/testdata/simplebin/src/main.rs
function main (line 3) | fn main() {
FILE: tracers-codegen/testdata/simplelib/build.rs
function main (line 1) | fn main() {
FILE: tracers-codegen/testdata/simplelib/src/child_module.rs
type MyTraceProvider (line 4) | pub(super) trait MyTraceProvider {
method something_happend (line 5) | fn something_happend();
method something_else (line 7) | fn something_else(foo: &str, bar: usize);
function something (line 10) | pub fn something() {
FILE: tracers-codegen/testdata/simplelib/src/lib.rs
function something_else (line 4) | pub fn something_else() {
function it_works (line 11) | fn it_works() {
FILE: tracers-core/build.rs
constant MAX_ARITY (line 14) | const MAX_ARITY: usize = 12;
constant MAX_QUICKCHECK_ARITY (line 15) | const MAX_QUICKCHECK_ARITY: usize = 8;
function main (line 17) | fn main() -> Fallible<()> {
function get_type_param_names (line 36) | fn get_type_param_names(args: usize) -> Vec<String> {
function make_tuple_type (line 41) | fn make_tuple_type(type_params: &Vec<String>) -> String {
function xform_types (line 49) | fn xform_types<F: FnMut(&String) -> String>(type_params: &Vec<String>, m...
function xform_types_i (line 53) | fn xform_types_i<F: FnMut(usize, &String) -> String>(
function generate_probe_args_impl (line 64) | fn generate_probe_args_impl(type_params: &Vec<String>) -> String {
function generate_unsafe_provider_probe_impl_trait (line 97) | fn generate_unsafe_provider_probe_impl_trait() -> String {
function generate_unsafe_provider_probe_native_impl_trait (line 147) | fn generate_unsafe_provider_probe_native_impl_trait() -> String {
function generate_tests (line 245) | fn generate_tests() -> String {
function generate_test_unsafe_probe_impl (line 256) | fn generate_test_unsafe_probe_impl() -> String {
function generate_probe_tests (line 318) | fn generate_probe_tests() -> String {
FILE: tracers-core/src/argtypes.rs
type CType (line 42) | pub enum CType {
type ProbeArgNativeTypeInfo (line 82) | pub trait ProbeArgNativeTypeInfo {
method get_c_type (line 83) | fn get_c_type() -> CType;
method get_c_type_str (line 85) | fn get_c_type_str() -> &'static str {
method get_rust_type_str (line 90) | fn get_rust_type_str() -> &'static str;
type ProbeArgNativeType (line 95) | pub trait ProbeArgNativeType<T>: ProbeArgNativeTypeInfo {
method get_default_value (line 96) | fn get_default_value() -> T;
type ProbeArgType (line 104) | pub trait ProbeArgType<T> {
method wrap (line 107) | fn wrap(arg: T) -> Self::WrapperType;
type ProbeArgWrapper (line 113) | pub trait ProbeArgWrapper: Debug
method as_c_type (line 123) | fn as_c_type(&self) -> Self::CType;
method default_c_value (line 127) | fn default_c_value() -> Self::CType {
function wrap (line 133) | pub fn wrap<T: ProbeArgType<T>>(arg: T) -> <T as ProbeArgType<T>>::Wrapp...
FILE: tracers-core/src/argtypes/bool.rs
type WrapperType (line 4) | type WrapperType = bool;
function wrap (line 5) | fn wrap(arg: bool) -> Self::WrapperType {
type CType (line 11) | type CType = i32;
method as_c_type (line 13) | fn as_c_type(&self) -> Self::CType {
function as_c_type (line 23) | fn as_c_type() {
FILE: tracers-core/src/argtypes/cstring.rs
type WrapperType (line 8) | type WrapperType = &'a CStr;
function wrap (line 9) | fn wrap(arg: &'a CStr) -> Self::WrapperType {
type WrapperType (line 15) | type WrapperType = &'a CString;
function wrap (line 16) | fn wrap(arg: &'a CString) -> Self::WrapperType {
type CType (line 22) | type CType = *const c_char;
method as_c_type (line 24) | fn as_c_type(&self) -> Self::CType {
type CType (line 30) | type CType = *const c_char;
method as_c_type (line 32) | fn as_c_type(&self) -> Self::CType {
function cstring_to_cstring (line 44) | fn cstring_to_cstring(x: String) -> TestResult {
FILE: tracers-core/src/argtypes/option.rs
type WrapperType (line 16) | type WrapperType = Option<<T as ProbeArgType<T>>::WrapperType>;
function wrap (line 18) | fn wrap(arg: &Option<T>) -> Self::WrapperType {
type WrapperType (line 29) | type WrapperType = Option<CString>;
function wrap (line 31) | fn wrap(arg: &Option<String>) -> Self::WrapperType {
type CType (line 40) | type CType = <T as ProbeArgWrapper>::CType;
method as_c_type (line 42) | fn as_c_type(&self) -> Self::CType {
function option_ints (line 57) | fn option_ints(x: i64) -> bool {
function option_strings (line 67) | fn option_strings(x: String) -> bool {
FILE: tracers-core/src/argtypes/pointer.rs
type WrapperType (line 5) | type WrapperType = *const T;
function wrap (line 6) | fn wrap(arg: *const T) -> Self::WrapperType {
type CType (line 12) | type CType = *const raw::c_void;
method as_c_type (line 14) | fn as_c_type(&self) -> Self::CType {
function null_pointer (line 26) | fn null_pointer() {
function non_null_pointer (line 34) | fn non_null_pointer() {
FILE: tracers-core/src/argtypes/refs.rs
type WrapperType (line 11) | type WrapperType = <T as ProbeArgType<T>>::WrapperType;
function wrap (line 13) | fn wrap(arg: &'a T) -> Self::WrapperType {
function ref_str (line 23) | fn ref_str() {
function ref_int (line 34) | fn ref_int() {
FILE: tracers-core/src/argtypes/string.rs
type WrapperType (line 20) | type WrapperType = Option<CString>;
function wrap (line 21) | fn wrap(arg: &str) -> Self::WrapperType {
type WrapperType (line 27) | type WrapperType = Option<CString>;
function wrap (line 28) | fn wrap(arg: &String) -> Self::WrapperType {
type WrapperType (line 35) | type WrapperType = Option<CString>;
function wrap (line 36) | fn wrap(arg: &OsStr) -> Self::WrapperType {
type WrapperType (line 43) | type WrapperType = Option<CString>;
function wrap (line 44) | fn wrap(arg: &OsString) -> Self::WrapperType {
type CType (line 50) | type CType = *const c_char;
method as_c_type (line 52) | fn as_c_type(&self) -> Self::CType {
function string_as_c_type (line 75) | fn string_as_c_type(x: String) -> bool {
function str_as_c_type (line 83) | fn str_as_c_type(x: String) -> bool {
function osstring_as_c_type (line 92) | fn osstring_as_c_type(x: OsString) -> bool {
function osstr_as_c_type (line 101) | fn osstr_as_c_type(x: OsString) -> bool {
type StringHelpers (line 110) | trait StringHelpers {
method to_cstring (line 111) | fn to_cstring(&self) -> Option<CString>;
method assert_equals (line 112) | fn assert_equals(&self, x: &str) -> ();
method to_cstring (line 116) | fn to_cstring(&self) -> Option<CString> {
method assert_equals (line 119) | fn assert_equals(&self, x: &str) {
method to_cstring (line 125) | fn to_cstring(&self) -> Option<CString> {
method assert_equals (line 128) | fn assert_equals(&self, x: &str) {
method to_cstring (line 135) | fn to_cstring(&self) -> Option<CString> {
method assert_equals (line 139) | fn assert_equals(&self, x: &str) {
method to_cstring (line 146) | fn to_cstring(&self) -> Option<CString> {
method assert_equals (line 149) | fn assert_equals(&self, x: &str) {
function test_with_string (line 154) | fn test_with_string<T: StringHelpers + ProbeArgType<T> + Debug>(x: T, po...
FILE: tracers-core/src/dynamic.rs
type Tracer (line 16) | pub trait Tracer: Sized {
constant TRACING_IMPLEMENTATION (line 17) | const TRACING_IMPLEMENTATION: &'static str;
method define_provider (line 30) | fn define_provider(
type ProviderBuilder (line 36) | pub trait ProviderBuilder<TracerT: Tracer> {
method add_probe (line 37) | fn add_probe<ArgsT: ProbeArgs<ArgsT>>(&mut self, name: &'static str) -...
method build (line 38) | fn build(self, name: &str) -> Fallible<<TracerT as Tracer>::ProviderTy...
type Provider (line 41) | pub trait Provider<TracerT: Tracer> {
method get_probe (line 42) | fn get_probe<ArgsT: ProbeArgs<ArgsT>>(
method get_probe_unsafe (line 51) | fn get_probe_unsafe(
type ProviderProbe (line 60) | pub struct ProviderProbe<'probe, ImplT: UnsafeProviderProbeImpl, ArgsT: ...
function new (line 68) | fn new(probe: &'probe ImplT) -> Self {
function is_enabled (line 78) | pub fn is_enabled(&self) -> bool {
function fire (line 84) | pub fn fire(&self, args: ArgsT) {
type ProbeArgs (line 104) | pub trait ProbeArgs<T> {
constant ARG_COUNT (line 106) | const ARG_COUNT: usize;
method arg_types (line 110) | fn arg_types() -> Vec<CType>;
method fire_probe (line 114) | fn fire_probe<ImplT: UnsafeProviderProbeImpl>(self, probe: &ImplT);
type ProbeDefinition (line 122) | pub struct ProbeDefinition {
method new (line 128) | pub fn new<ArgsT: ProbeArgs<ArgsT>>(name: &'static str) -> ProbeDefini...
function get_ctype (line 138) | fn get_ctype<T: ProbeArgType<T>>() -> CType {
constant BUFFER_SIZE (line 156) | const BUFFER_SIZE: usize = 8192;
type TestingProviderProbeImpl (line 163) | struct TestingProviderProbeImpl {
method new (line 171) | pub fn new(format_string: String) -> TestingProviderProbeImpl {
method log_call (line 184) | fn log_call(&self) {
method get_calls (line 193) | fn get_calls(&self) -> Vec<String> {
function c_and_back_again (line 202) | fn c_and_back_again(arg: &str) -> String {
function test_fire0 (line 211) | fn test_fire0() {
FILE: tracers-core/src/lib.rs
type ProviderInitResult (line 30) | pub type ProviderInitResult = std::result::Result<&'static str, &'static...
FILE: tracers-dyn-noop/build.rs
constant MAX_ARITY (line 9) | const MAX_ARITY: usize = 12;
function main (line 11) | fn main() -> Fallible<()> {
function get_type_param_names (line 21) | fn get_type_param_names(args: usize) -> Vec<String> {
function xform_types (line 26) | fn xform_types<F: FnMut(&String) -> String>(type_params: &Vec<String>, m...
function xform_types_i (line 30) | fn xform_types_i<F: FnMut(usize, &String) -> String>(
function generate_stap_native_impl (line 41) | fn generate_stap_native_impl() -> String {
FILE: tracers-dyn-noop/src/probe.rs
type NoOpProbe (line 6) | pub struct NoOpProbe {}
FILE: tracers-dyn-noop/src/provider.rs
type NoOpProviderBuilder (line 7) | pub struct NoOpProviderBuilder {}
method new (line 10) | pub(crate) fn new() -> NoOpProviderBuilder {
method add_probe (line 16) | fn add_probe<ArgsT: ProbeArgs<ArgsT>>(&mut self, _name: &'static str) ...
method build (line 20) | fn build(self, _name: &str) -> Fallible<NoOpProvider> {
type NoOpProvider (line 25) | pub struct NoOpProvider {}
method get_probe_unsafe (line 35) | fn get_probe_unsafe(&self, _definition: &ProbeDefinition) -> Fallible<...
FILE: tracers-dyn-noop/src/tracer.rs
type NoOpTracer (line 11) | pub struct NoOpTracer {}
constant TRACING_IMPLEMENTATION (line 14) | const TRACING_IMPLEMENTATION: &'static str = "no-op";
type ProviderBuilderType (line 16) | type ProviderBuilderType = NoOpProviderBuilder;
type ProviderType (line 17) | type ProviderType = NoOpProvider;
type ProbeType (line 18) | type ProbeType = NoOpProbe;
method define_provider (line 20) | fn define_provider(
FILE: tracers-dyn-stap/build.rs
constant MAX_ARITY (line 9) | const MAX_ARITY: usize = 12;
constant STAP_MAX_ARITY (line 10) | const STAP_MAX_ARITY: usize = 6;
function is_enabled (line 12) | fn is_enabled() -> bool {
function is_required (line 16) | fn is_required() -> bool {
function main (line 20) | fn main() {
function try_build (line 51) | fn try_build() -> Fallible<()> {
function get_type_param_names (line 65) | fn get_type_param_names(args: usize) -> Vec<String> {
function xform_types (line 70) | fn xform_types<F: FnMut(&String) -> String>(type_params: &Vec<String>, m...
function xform_types_i (line 74) | fn xform_types_i<F: FnMut(usize, &String) -> String>(
function generate_stap_native_impl (line 85) | fn generate_stap_native_impl() -> String {
FILE: tracers-dyn-stap/src/probe.rs
type StapProbe (line 9) | pub struct StapProbe {
method is_enabled (line 15) | fn is_enabled(&self) -> bool {
FILE: tracers-dyn-stap/src/provider.rs
type StapError (line 13) | pub enum StapError {
type StapProviderBuilder (line 27) | pub struct StapProviderBuilder {
method new (line 32) | pub(crate) fn new() -> StapProviderBuilder {
method add_probe (line 38) | fn add_probe<ArgsT: ProbeArgs<ArgsT>>(&mut self, name: &'static str) -...
method build (line 53) | fn build(self, name: &str) -> Fallible<StapProvider> {
type StapProvider (line 66) | pub struct StapProvider {
method new (line 87) | fn new(name: &str) -> Fallible<StapProvider> {
method add_probe (line 108) | fn add_probe(&mut self, definition: ProbeDefinition) -> Fallible<()> {
method load (line 189) | fn load(&mut self) -> Fallible<()> {
method get_arg_type (line 203) | fn get_arg_type(typ: CType) -> ArgType_t {
method get_probe_unsafe (line 225) | fn get_probe_unsafe(&self, definition: &ProbeDefinition) -> Fallible<&...
method drop (line 241) | fn drop(&mut self) {
FILE: tracers-dyn-stap/src/tracer.rs
type StapTracer (line 9) | pub struct StapTracer {}
constant TRACING_IMPLEMENTATION (line 12) | const TRACING_IMPLEMENTATION: &'static str = "dyn_stap";
type ProviderBuilderType (line 14) | type ProviderBuilderType = StapProviderBuilder;
type ProviderType (line 15) | type ProviderType = StapProvider;
type ProbeType (line 16) | type ProbeType = StapProbe;
method define_provider (line 18) | fn define_provider(
method drop (line 31) | fn drop(&mut self) {}
FILE: tracers-libelf-sys/build.rs
function is_enabled (line 19) | fn is_enabled() -> bool {
function is_required (line 23) | fn is_required() -> bool {
function main (line 27) | fn main() {
function try_build (line 54) | fn try_build() -> Fallible<()> {
function run (line 125) | fn run(cmd: &mut Command, program: &str) -> Fallible<()> {
FILE: tracers-libelf-sys/src/lib.rs
function elf_version_is_correct (line 14) | fn elf_version_is_correct() {
FILE: tracers-libelf-sys/src/libelf.rs
constant _LIBELF_H (line 3) | pub const _LIBELF_H: u32 = 1;
constant _STDINT_H (line 4) | pub const _STDINT_H: u32 = 1;
constant _FEATURES_H (line 5) | pub const _FEATURES_H: u32 = 1;
constant _DEFAULT_SOURCE (line 6) | pub const _DEFAULT_SOURCE: u32 = 1;
constant __USE_ISOC11 (line 7) | pub const __USE_ISOC11: u32 = 1;
constant __USE_ISOC99 (line 8) | pub const __USE_ISOC99: u32 = 1;
constant __USE_ISOC95 (line 9) | pub const __USE_ISOC95: u32 = 1;
constant __USE_POSIX_IMPLICITLY (line 10) | pub const __USE_POSIX_IMPLICITLY: u32 = 1;
constant _POSIX_SOURCE (line 11) | pub const _POSIX_SOURCE: u32 = 1;
constant _POSIX_C_SOURCE (line 12) | pub const _POSIX_C_SOURCE: u32 = 200809;
constant __USE_POSIX (line 13) | pub const __USE_POSIX: u32 = 1;
constant __USE_POSIX2 (line 14) | pub const __USE_POSIX2: u32 = 1;
constant __USE_POSIX199309 (line 15) | pub const __USE_POSIX199309: u32 = 1;
constant __USE_POSIX199506 (line 16) | pub const __USE_POSIX199506: u32 = 1;
constant __USE_XOPEN2K (line 17) | pub const __USE_XOPEN2K: u32 = 1;
constant __USE_XOPEN2K8 (line 18) | pub const __USE_XOPEN2K8: u32 = 1;
constant _ATFILE_SOURCE (line 19) | pub const _ATFILE_SOURCE: u32 = 1;
constant __USE_MISC (line 20) | pub const __USE_MISC: u32 = 1;
constant __USE_ATFILE (line 21) | pub const __USE_ATFILE: u32 = 1;
constant __USE_FORTIFY_LEVEL (line 22) | pub const __USE_FORTIFY_LEVEL: u32 = 0;
constant __GLIBC_USE_DEPRECATED_GETS (line 23) | pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
constant _STDC_PREDEF_H (line 24) | pub const _STDC_PREDEF_H: u32 = 1;
constant __STDC_IEC_559__ (line 25) | pub const __STDC_IEC_559__: u32 = 1;
constant __STDC_IEC_559_COMPLEX__ (line 26) | pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
constant __STDC_ISO_10646__ (line 27) | pub const __STDC_ISO_10646__: u32 = 201706;
constant __GNU_LIBRARY__ (line 28) | pub const __GNU_LIBRARY__: u32 = 6;
constant __GLIBC__ (line 29) | pub const __GLIBC__: u32 = 2;
constant __GLIBC_MINOR__ (line 30) | pub const __GLIBC_MINOR__: u32 = 28;
constant _SYS_CDEFS_H (line 31) | pub const _SYS_CDEFS_H: u32 = 1;
constant __glibc_c99_flexarr_available (line 32) | pub const __glibc_c99_flexarr_available: u32 = 1;
constant __WORDSIZE (line 33) | pub const __WORDSIZE: u32 = 64;
constant __WORDSIZE_TIME64_COMPAT32 (line 34) | pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
constant __SYSCALL_WORDSIZE (line 35) | pub const __SYSCALL_WORDSIZE: u32 = 64;
constant __HAVE_GENERIC_SELECTION (line 36) | pub const __HAVE_GENERIC_SELECTION: u32 = 1;
constant __GLIBC_USE_LIB_EXT2 (line 37) | pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
constant __GLIBC_USE_IEC_60559_BFP_EXT (line 38) | pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
constant __GLIBC_USE_IEC_60559_FUNCS_EXT (line 39) | pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
constant __GLIBC_USE_IEC_60559_TYPES_EXT (line 40) | pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
constant _BITS_TYPES_H (line 41) | pub const _BITS_TYPES_H: u32 = 1;
constant _BITS_TYPESIZES_H (line 42) | pub const _BITS_TYPESIZES_H: u32 = 1;
constant __OFF_T_MATCHES_OFF64_T (line 43) | pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
constant __INO_T_MATCHES_INO64_T (line 44) | pub const __INO_T_MATCHES_INO64_T: u32 = 1;
constant __RLIM_T_MATCHES_RLIM64_T (line 45) | pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
constant __FD_SETSIZE (line 46) | pub const __FD_SETSIZE: u32 = 1024;
constant _BITS_WCHAR_H (line 47) | pub const _BITS_WCHAR_H: u32 = 1;
constant _BITS_STDINT_INTN_H (line 48) | pub const _BITS_STDINT_INTN_H: u32 = 1;
constant _BITS_STDINT_UINTN_H (line 49) | pub const _BITS_STDINT_UINTN_H: u32 = 1;
constant INT8_MIN (line 50) | pub const INT8_MIN: i32 = -128;
constant INT16_MIN (line 51) | pub const INT16_MIN: i32 = -32768;
constant INT32_MIN (line 52) | pub const INT32_MIN: i32 = -2147483648;
constant INT8_MAX (line 53) | pub const INT8_MAX: u32 = 127;
constant INT16_MAX (line 54) | pub const INT16_MAX: u32 = 32767;
constant INT32_MAX (line 55) | pub const INT32_MAX: u32 = 2147483647;
constant UINT8_MAX (line 56) | pub const UINT8_MAX: u32 = 255;
constant UINT16_MAX (line 57) | pub const UINT16_MAX: u32 = 65535;
constant UINT32_MAX (line 58) | pub const UINT32_MAX: u32 = 4294967295;
constant INT_LEAST8_MIN (line 59) | pub const INT_LEAST8_MIN: i32 = -128;
constant INT_LEAST16_MIN (line 60) | pub const INT_LEAST16_MIN: i32 = -32768;
constant INT_LEAST32_MIN (line 61) | pub const INT_LEAST32_MIN: i32 = -2147483648;
constant INT_LEAST8_MAX (line 62) | pub const INT_LEAST8_MAX: u32 = 127;
constant INT_LEAST16_MAX (line 63) | pub const INT_LEAST16_MAX: u32 = 32767;
constant INT_LEAST32_MAX (line 64) | pub const INT_LEAST32_MAX: u32 = 2147483647;
constant UINT_LEAST8_MAX (line 65) | pub const UINT_LEAST8_MAX: u32 = 255;
constant UINT_LEAST16_MAX (line 66) | pub const UINT_LEAST16_MAX: u32 = 65535;
constant UINT_LEAST32_MAX (line 67) | pub const UINT_LEAST32_MAX: u32 = 4294967295;
constant INT_FAST8_MIN (line 68) | pub const INT_FAST8_MIN: i32 = -128;
constant INT_FAST16_MIN (line 69) | pub const INT_FAST16_MIN: i64 = -9223372036854775808;
constant INT_FAST32_MIN (line 70) | pub const INT_FAST32_MIN: i64 = -9223372036854775808;
constant INT_FAST8_MAX (line 71) | pub const INT_FAST8_MAX: u32 = 127;
constant INT_FAST16_MAX (line 72) | pub const INT_FAST16_MAX: u64 = 9223372036854775807;
constant INT_FAST32_MAX (line 73) | pub const INT_FAST32_MAX: u64 = 9223372036854775807;
constant UINT_FAST8_MAX (line 74) | pub const UINT_FAST8_MAX: u32 = 255;
constant UINT_FAST16_MAX (line 75) | pub const UINT_FAST16_MAX: i32 = -1;
constant UINT_FAST32_MAX (line 76) | pub const UINT_FAST32_MAX: i32 = -1;
constant INTPTR_MIN (line 77) | pub const INTPTR_MIN: i64 = -9223372036854775808;
constant INTPTR_MAX (line 78) | pub const INTPTR_MAX: u64 = 9223372036854775807;
constant UINTPTR_MAX (line 79) | pub const UINTPTR_MAX: i32 = -1;
constant PTRDIFF_MIN (line 80) | pub const PTRDIFF_MIN: i64 = -9223372036854775808;
constant PTRDIFF_MAX (line 81) | pub const PTRDIFF_MAX: u64 = 9223372036854775807;
constant SIG_ATOMIC_MIN (line 82) | pub const SIG_ATOMIC_MIN: i32 = -2147483648;
constant SIG_ATOMIC_MAX (line 83) | pub const SIG_ATOMIC_MAX: u32 = 2147483647;
constant SIZE_MAX (line 84) | pub const SIZE_MAX: i32 = -1;
constant WINT_MIN (line 85) | pub const WINT_MIN: u32 = 0;
constant WINT_MAX (line 86) | pub const WINT_MAX: u32 = 4294967295;
constant _SYS_TYPES_H (line 87) | pub const _SYS_TYPES_H: u32 = 1;
constant __clock_t_defined (line 88) | pub const __clock_t_defined: u32 = 1;
constant __clockid_t_defined (line 89) | pub const __clockid_t_defined: u32 = 1;
constant __time_t_defined (line 90) | pub const __time_t_defined: u32 = 1;
constant __timer_t_defined (line 91) | pub const __timer_t_defined: u32 = 1;
constant __BIT_TYPES_DEFINED__ (line 92) | pub const __BIT_TYPES_DEFINED__: u32 = 1;
constant _ENDIAN_H (line 93) | pub const _ENDIAN_H: u32 = 1;
constant __LITTLE_ENDIAN (line 94) | pub const __LITTLE_ENDIAN: u32 = 1234;
constant __BIG_ENDIAN (line 95) | pub const __BIG_ENDIAN: u32 = 4321;
constant __PDP_ENDIAN (line 96) | pub const __PDP_ENDIAN: u32 = 3412;
constant __BYTE_ORDER (line 97) | pub const __BYTE_ORDER: u32 = 1234;
constant __FLOAT_WORD_ORDER (line 98) | pub const __FLOAT_WORD_ORDER: u32 = 1234;
constant LITTLE_ENDIAN (line 99) | pub const LITTLE_ENDIAN: u32 = 1234;
constant BIG_ENDIAN (line 100) | pub const BIG_ENDIAN: u32 = 4321;
constant PDP_ENDIAN (line 101) | pub const PDP_ENDIAN: u32 = 3412;
constant BYTE_ORDER (line 102) | pub const BYTE_ORDER: u32 = 1234;
constant _BITS_BYTESWAP_H (line 103) | pub const _BITS_BYTESWAP_H: u32 = 1;
constant _BITS_UINTN_IDENTITY_H (line 104) | pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
constant _SYS_SELECT_H (line 105) | pub const _SYS_SELECT_H: u32 = 1;
constant __FD_ZERO_STOS (line 106) | pub const __FD_ZERO_STOS: &'static [u8; 6usize] = b"stosq\0";
constant __sigset_t_defined (line 107) | pub const __sigset_t_defined: u32 = 1;
constant __timeval_defined (line 108) | pub const __timeval_defined: u32 = 1;
constant _STRUCT_TIMESPEC (line 109) | pub const _STRUCT_TIMESPEC: u32 = 1;
constant FD_SETSIZE (line 110) | pub const FD_SETSIZE: u32 = 1024;
constant _BITS_PTHREADTYPES_COMMON_H (line 111) | pub const _BITS_PTHREADTYPES_COMMON_H: u32 = 1;
constant _THREAD_SHARED_TYPES_H (line 112) | pub const _THREAD_SHARED_TYPES_H: u32 = 1;
constant _BITS_PTHREADTYPES_ARCH_H (line 113) | pub const _BITS_PTHREADTYPES_ARCH_H: u32 = 1;
constant __SIZEOF_PTHREAD_MUTEX_T (line 114) | pub const __SIZEOF_PTHREAD_MUTEX_T: u32 = 40;
constant __SIZEOF_PTHREAD_ATTR_T (line 115) | pub const __SIZEOF_PTHREAD_ATTR_T: u32 = 56;
constant __SIZEOF_PTHREAD_RWLOCK_T (line 116) | pub const __SIZEOF_PTHREAD_RWLOCK_T: u32 = 56;
constant __SIZEOF_PTHREAD_BARRIER_T (line 117) | pub const __SIZEOF_PTHREAD_BARRIER_T: u32 = 32;
constant __SIZEOF_PTHREAD_MUTEXATTR_T (line 118) | pub const __SIZEOF_PTHREAD_MUTEXATTR_T: u32 = 4;
constant __SIZEOF_PTHREAD_COND_T (line 119) | pub const __SIZEOF_PTHREAD_COND_T: u32 = 48;
constant __SIZEOF_PTHREAD_CONDATTR_T (line 120) | pub const __SIZEOF_PTHREAD_CONDATTR_T: u32 = 4;
constant __SIZEOF_PTHREAD_RWLOCKATTR_T (line 121) | pub const __SIZEOF_PTHREAD_RWLOCKATTR_T: u32 = 8;
constant __SIZEOF_PTHREAD_BARRIERATTR_T (line 122) | pub const __SIZEOF_PTHREAD_BARRIERATTR_T: u32 = 4;
constant __PTHREAD_MUTEX_LOCK_ELISION (line 123) | pub const __PTHREAD_MUTEX_LOCK_ELISION: u32 = 1;
constant __PTHREAD_MUTEX_NUSERS_AFTER_KIND (line 124) | pub const __PTHREAD_MUTEX_NUSERS_AFTER_KIND: u32 = 0;
constant __PTHREAD_MUTEX_USE_UNION (line 125) | pub const __PTHREAD_MUTEX_USE_UNION: u32 = 0;
constant __PTHREAD_RWLOCK_INT_FLAGS_SHARED (line 126) | pub const __PTHREAD_RWLOCK_INT_FLAGS_SHARED: u32 = 1;
constant __PTHREAD_MUTEX_HAVE_PREV (line 127) | pub const __PTHREAD_MUTEX_HAVE_PREV: u32 = 1;
constant __have_pthread_attr_t (line 128) | pub const __have_pthread_attr_t: u32 = 1;
constant _ELF_H (line 129) | pub const _ELF_H: u32 = 1;
constant EI_NIDENT (line 130) | pub const EI_NIDENT: u32 = 16;
constant EI_MAG0 (line 131) | pub const EI_MAG0: u32 = 0;
constant ELFMAG0 (line 132) | pub const ELFMAG0: u32 = 127;
constant EI_MAG1 (line 133) | pub const EI_MAG1: u32 = 1;
constant ELFMAG1 (line 134) | pub const ELFMAG1: u8 = 69u8;
constant EI_MAG2 (line 135) | pub const EI_MAG2: u32 = 2;
constant ELFMAG2 (line 136) | pub const ELFMAG2: u8 = 76u8;
constant EI_MAG3 (line 137) | pub const EI_MAG3: u32 = 3;
constant ELFMAG3 (line 138) | pub const ELFMAG3: u8 = 70u8;
constant ELFMAG (line 139) | pub const ELFMAG: &'static [u8; 5usize] = b"\x7FELF\0";
constant SELFMAG (line 140) | pub const SELFMAG: u32 = 4;
constant EI_CLASS (line 141) | pub const EI_CLASS: u32 = 4;
constant ELFCLASSNONE (line 142) | pub const ELFCLASSNONE: u32 = 0;
constant ELFCLASS32 (line 143) | pub const ELFCLASS32: u32 = 1;
constant ELFCLASS64 (line 144) | pub const ELFCLASS64: u32 = 2;
constant ELFCLASSNUM (line 145) | pub const ELFCLASSNUM: u32 = 3;
constant EI_DATA (line 146) | pub const EI_DATA: u32 = 5;
constant ELFDATANONE (line 147) | pub const ELFDATANONE: u32 = 0;
constant ELFDATA2LSB (line 148) | pub const ELFDATA2LSB: u32 = 1;
constant ELFDATA2MSB (line 149) | pub const ELFDATA2MSB: u32 = 2;
constant ELFDATANUM (line 150) | pub const ELFDATANUM: u32 = 3;
constant EI_VERSION (line 151) | pub const EI_VERSION: u32 = 6;
constant EI_OSABI (line 152) | pub const EI_OSABI: u32 = 7;
constant ELFOSABI_NONE (line 153) | pub const ELFOSABI_NONE: u32 = 0;
constant ELFOSABI_SYSV (line 154) | pub const ELFOSABI_SYSV: u32 = 0;
constant ELFOSABI_HPUX (line 155) | pub const ELFOSABI_HPUX: u32 = 1;
constant ELFOSABI_NETBSD (line 156) | pub const ELFOSABI_NETBSD: u32 = 2;
constant ELFOSABI_GNU (line 157) | pub const ELFOSABI_GNU: u32 = 3;
constant ELFOSABI_LINUX (line 158) | pub const ELFOSABI_LINUX: u32 = 3;
constant ELFOSABI_SOLARIS (line 159) | pub const ELFOSABI_SOLARIS: u32 = 6;
constant ELFOSABI_AIX (line 160) | pub const ELFOSABI_AIX: u32 = 7;
constant ELFOSABI_IRIX (line 161) | pub const ELFOSABI_IRIX: u32 = 8;
constant ELFOSABI_FREEBSD (line 162) | pub const ELFOSABI_FREEBSD: u32 = 9;
constant ELFOSABI_TRU64 (line 163) | pub const ELFOSABI_TRU64: u32 = 10;
constant ELFOSABI_MODESTO (line 164) | pub const ELFOSABI_MODESTO: u32 = 11;
constant ELFOSABI_OPENBSD (line 165) | pub const ELFOSABI_OPENBSD: u32 = 12;
constant ELFOSABI_ARM_AEABI (line 166) | pub const ELFOSABI_ARM_AEABI: u32 = 64;
constant ELFOSABI_ARM (line 167) | pub const ELFOSABI_ARM: u32 = 97;
constant ELFOSABI_STANDALONE (line 168) | pub const ELFOSABI_STANDALONE: u32 = 255;
constant EI_ABIVERSION (line 169) | pub const EI_ABIVERSION: u32 = 8;
constant EI_PAD (line 170) | pub const EI_PAD: u32 = 9;
constant ET_NONE (line 171) | pub const ET_NONE: u32 = 0;
constant ET_REL (line 172) | pub const ET_REL: u32 = 1;
constant ET_EXEC (line 173) | pub const ET_EXEC: u32 = 2;
constant ET_DYN (line 174) | pub const ET_DYN: u32 = 3;
constant ET_CORE (line 175) | pub const ET_CORE: u32 = 4;
constant ET_NUM (line 176) | pub const ET_NUM: u32 = 5;
constant ET_LOOS (line 177) | pub const ET_LOOS: u32 = 65024;
constant ET_HIOS (line 178) | pub const ET_HIOS: u32 = 65279;
constant ET_LOPROC (line 179) | pub const ET_LOPROC: u32 = 65280;
constant ET_HIPROC (line 180) | pub const ET_HIPROC: u32 = 65535;
constant EM_NONE (line 181) | pub const EM_NONE: u32 = 0;
constant EM_M32 (line 182) | pub const EM_M32: u32 = 1;
constant EM_SPARC (line 183) | pub const EM_SPARC: u32 = 2;
constant EM_386 (line 184) | pub const EM_386: u32 = 3;
constant EM_68K (line 185) | pub const EM_68K: u32 = 4;
constant EM_88K (line 186) | pub const EM_88K: u32 = 5;
constant EM_IAMCU (line 187) | pub const EM_IAMCU: u32 = 6;
constant EM_860 (line 188) | pub const EM_860: u32 = 7;
constant EM_MIPS (line 189) | pub const EM_MIPS: u32 = 8;
constant EM_S370 (line 190) | pub const EM_S370: u32 = 9;
constant EM_MIPS_RS3_LE (line 191) | pub const EM_MIPS_RS3_LE: u32 = 10;
constant EM_PARISC (line 192) | pub const EM_PARISC: u32 = 15;
constant EM_VPP500 (line 193) | pub const EM_VPP500: u32 = 17;
constant EM_SPARC32PLUS (line 194) | pub const EM_SPARC32PLUS: u32 = 18;
constant EM_960 (line 195) | pub const EM_960: u32 = 19;
constant EM_PPC (line 196) | pub const EM_PPC: u32 = 20;
constant EM_PPC64 (line 197) | pub const EM_PPC64: u32 = 21;
constant EM_S390 (line 198) | pub const EM_S390: u32 = 22;
constant EM_SPU (line 199) | pub const EM_SPU: u32 = 23;
constant EM_V800 (line 200) | pub const EM_V800: u32 = 36;
constant EM_FR20 (line 201) | pub const EM_FR20: u32 = 37;
constant EM_RH32 (line 202) | pub const EM_RH32: u32 = 38;
constant EM_RCE (line 203) | pub const EM_RCE: u32 = 39;
constant EM_ARM (line 204) | pub const EM_ARM: u32 = 40;
constant EM_FAKE_ALPHA (line 205) | pub const EM_FAKE_ALPHA: u32 = 41;
constant EM_SH (line 206) | pub const EM_SH: u32 = 42;
constant EM_SPARCV9 (line 207) | pub const EM_SPARCV9: u32 = 43;
constant EM_TRICORE (line 208) | pub const EM_TRICORE: u32 = 44;
constant EM_ARC (line 209) | pub const EM_ARC: u32 = 45;
constant EM_H8_300 (line 210) | pub const EM_H8_300: u32 = 46;
constant EM_H8_300H (line 211) | pub const EM_H8_300H: u32 = 47;
constant EM_H8S (line 212) | pub const EM_H8S: u32 = 48;
constant EM_H8_500 (line 213) | pub const EM_H8_500: u32 = 49;
constant EM_IA_64 (line 214) | pub const EM_IA_64: u32 = 50;
constant EM_MIPS_X (line 215) | pub const EM_MIPS_X: u32 = 51;
constant EM_COLDFIRE (line 216) | pub const EM_COLDFIRE: u32 = 52;
constant EM_68HC12 (line 217) | pub const EM_68HC12: u32 = 53;
constant EM_MMA (line 218) | pub const EM_MMA: u32 = 54;
constant EM_PCP (line 219) | pub const EM_PCP: u32 = 55;
constant EM_NCPU (line 220) | pub const EM_NCPU: u32 = 56;
constant EM_NDR1 (line 221) | pub const EM_NDR1: u32 = 57;
constant EM_STARCORE (line 222) | pub const EM_STARCORE: u32 = 58;
constant EM_ME16 (line 223) | pub const EM_ME16: u32 = 59;
constant EM_ST100 (line 224) | pub const EM_ST100: u32 = 60;
constant EM_TINYJ (line 225) | pub const EM_TINYJ: u32 = 61;
constant EM_X86_64 (line 226) | pub const EM_X86_64: u32 = 62;
constant EM_PDSP (line 227) | pub const EM_PDSP: u32 = 63;
constant EM_PDP10 (line 228) | pub const EM_PDP10: u32 = 64;
constant EM_PDP11 (line 229) | pub const EM_PDP11: u32 = 65;
constant EM_FX66 (line 230) | pub const EM_FX66: u32 = 66;
constant EM_ST9PLUS (line 231) | pub const EM_ST9PLUS: u32 = 67;
constant EM_ST7 (line 232) | pub const EM_ST7: u32 = 68;
constant EM_68HC16 (line 233) | pub const EM_68HC16: u32 = 69;
constant EM_68HC11 (line 234) | pub const EM_68HC11: u32 = 70;
constant EM_68HC08 (line 235) | pub const EM_68HC08: u32 = 71;
constant EM_68HC05 (line 236) | pub const EM_68HC05: u32 = 72;
constant EM_SVX (line 237) | pub const EM_SVX: u32 = 73;
constant EM_ST19 (line 238) | pub const EM_ST19: u32 = 74;
constant EM_VAX (line 239) | pub const EM_VAX: u32 = 75;
constant EM_CRIS (line 240) | pub const EM_CRIS: u32 = 76;
constant EM_JAVELIN (line 241) | pub const EM_JAVELIN: u32 = 77;
constant EM_FIREPATH (line 242) | pub const EM_FIREPATH: u32 = 78;
constant EM_ZSP (line 243) | pub const EM_ZSP: u32 = 79;
constant EM_MMIX (line 244) | pub const EM_MMIX: u32 = 80;
constant EM_HUANY (line 245) | pub const EM_HUANY: u32 = 81;
constant EM_PRISM (line 246) | pub const EM_PRISM: u32 = 82;
constant EM_AVR (line 247) | pub const EM_AVR: u32 = 83;
constant EM_FR30 (line 248) | pub const EM_FR30: u32 = 84;
constant EM_D10V (line 249) | pub const EM_D10V: u32 = 85;
constant EM_D30V (line 250) | pub const EM_D30V: u32 = 86;
constant EM_V850 (line 251) | pub const EM_V850: u32 = 87;
constant EM_M32R (line 252) | pub const EM_M32R: u32 = 88;
constant EM_MN10300 (line 253) | pub const EM_MN10300: u32 = 89;
constant EM_MN10200 (line 254) | pub const EM_MN10200: u32 = 90;
constant EM_PJ (line 255) | pub const EM_PJ: u32 = 91;
constant EM_OPENRISC (line 256) | pub const EM_OPENRISC: u32 = 92;
constant EM_ARC_COMPACT (line 257) | pub const EM_ARC_COMPACT: u32 = 93;
constant EM_XTENSA (line 258) | pub const EM_XTENSA: u32 = 94;
constant EM_VIDEOCORE (line 259) | pub const EM_VIDEOCORE: u32 = 95;
constant EM_TMM_GPP (line 260) | pub const EM_TMM_GPP: u32 = 96;
constant EM_NS32K (line 261) | pub const EM_NS32K: u32 = 97;
constant EM_TPC (line 262) | pub const EM_TPC: u32 = 98;
constant EM_SNP1K (line 263) | pub const EM_SNP1K: u32 = 99;
constant EM_ST200 (line 264) | pub const EM_ST200: u32 = 100;
constant EM_IP2K (line 265) | pub const EM_IP2K: u32 = 101;
constant EM_MAX (line 266) | pub const EM_MAX: u32 = 102;
constant EM_CR (line 267) | pub const EM_CR: u32 = 103;
constant EM_F2MC16 (line 268) | pub const EM_F2MC16: u32 = 104;
constant EM_MSP430 (line 269) | pub const EM_MSP430: u32 = 105;
constant EM_BLACKFIN (line 270) | pub const EM_BLACKFIN: u32 = 106;
constant EM_SE_C33 (line 271) | pub const EM_SE_C33: u32 = 107;
constant EM_SEP (line 272) | pub const EM_SEP: u32 = 108;
constant EM_ARCA (line 273) | pub const EM_ARCA: u32 = 109;
constant EM_UNICORE (line 274) | pub const EM_UNICORE: u32 = 110;
constant EM_EXCESS (line 275) | pub const EM_EXCESS: u32 = 111;
constant EM_DXP (line 276) | pub const EM_DXP: u32 = 112;
constant EM_ALTERA_NIOS2 (line 277) | pub const EM_ALTERA_NIOS2: u32 = 113;
constant EM_CRX (line 278) | pub const EM_CRX: u32 = 114;
constant EM_XGATE (line 279) | pub const EM_XGATE: u32 = 115;
constant EM_C166 (line 280) | pub const EM_C166: u32 = 116;
constant EM_M16C (line 281) | pub const EM_M16C: u32 = 117;
constant EM_DSPIC30F (line 282) | pub const EM_DSPIC30F: u32 = 118;
constant EM_CE (line 283) | pub const EM_CE: u32 = 119;
constant EM_M32C (line 284) | pub const EM_M32C: u32 = 120;
constant EM_TSK3000 (line 285) | pub const EM_TSK3000: u32 = 131;
constant EM_RS08 (line 286) | pub const EM_RS08: u32 = 132;
constant EM_SHARC (line 287) | pub const EM_SHARC: u32 = 133;
constant EM_ECOG2 (line 288) | pub const EM_ECOG2: u32 = 134;
constant EM_SCORE7 (line 289) | pub const EM_SCORE7: u32 = 135;
constant EM_DSP24 (line 290) | pub const EM_DSP24: u32 = 136;
constant EM_VIDEOCORE3 (line 291) | pub const EM_VIDEOCORE3: u32 = 137;
constant EM_LATTICEMICO32 (line 292) | pub const EM_LATTICEMICO32: u32 = 138;
constant EM_SE_C17 (line 293) | pub const EM_SE_C17: u32 = 139;
constant EM_TI_C6000 (line 294) | pub const EM_TI_C6000: u32 = 140;
constant EM_TI_C2000 (line 295) | pub const EM_TI_C2000: u32 = 141;
constant EM_TI_C5500 (line 296) | pub const EM_TI_C5500: u32 = 142;
constant EM_TI_ARP32 (line 297) | pub const EM_TI_ARP32: u32 = 143;
constant EM_TI_PRU (line 298) | pub const EM_TI_PRU: u32 = 144;
constant EM_MMDSP_PLUS (line 299) | pub const EM_MMDSP_PLUS: u32 = 160;
constant EM_CYPRESS_M8C (line 300) | pub const EM_CYPRESS_M8C: u32 = 161;
constant EM_R32C (line 301) | pub const EM_R32C: u32 = 162;
constant EM_TRIMEDIA (line 302) | pub const EM_TRIMEDIA: u32 = 163;
constant EM_QDSP6 (line 303) | pub const EM_QDSP6: u32 = 164;
constant EM_8051 (line 304) | pub const EM_8051: u32 = 165;
constant EM_STXP7X (line 305) | pub const EM_STXP7X: u32 = 166;
constant EM_NDS32 (line 306) | pub const EM_NDS32: u32 = 167;
constant EM_ECOG1X (line 307) | pub const EM_ECOG1X: u32 = 168;
constant EM_MAXQ30 (line 308) | pub const EM_MAXQ30: u32 = 169;
constant EM_XIMO16 (line 309) | pub const EM_XIMO16: u32 = 170;
constant EM_MANIK (line 310) | pub const EM_MANIK: u32 = 171;
constant EM_CRAYNV2 (line 311) | pub const EM_CRAYNV2: u32 = 172;
constant EM_RX (line 312) | pub const EM_RX: u32 = 173;
constant EM_METAG (line 313) | pub const EM_METAG: u32 = 174;
constant EM_MCST_ELBRUS (line 314) | pub const EM_MCST_ELBRUS: u32 = 175;
constant EM_ECOG16 (line 315) | pub const EM_ECOG16: u32 = 176;
constant EM_CR16 (line 316) | pub const EM_CR16: u32 = 177;
constant EM_ETPU (line 317) | pub const EM_ETPU: u32 = 178;
constant EM_SLE9X (line 318) | pub const EM_SLE9X: u32 = 179;
constant EM_L10M (line 319) | pub const EM_L10M: u32 = 180;
constant EM_K10M (line 320) | pub const EM_K10M: u32 = 181;
constant EM_AARCH64 (line 321) | pub const EM_AARCH64: u32 = 183;
constant EM_AVR32 (line 322) | pub const EM_AVR32: u32 = 185;
constant EM_STM8 (line 323) | pub const EM_STM8: u32 = 186;
constant EM_TILE64 (line 324) | pub const EM_TILE64: u32 = 187;
constant EM_TILEPRO (line 325) | pub const EM_TILEPRO: u32 = 188;
constant EM_MICROBLAZE (line 326) | pub const EM_MICROBLAZE: u32 = 189;
constant EM_CUDA (line 327) | pub const EM_CUDA: u32 = 190;
constant EM_TILEGX (line 328) | pub const EM_TILEGX: u32 = 191;
constant EM_CLOUDSHIELD (line 329) | pub const EM_CLOUDSHIELD: u32 = 192;
constant EM_COREA_1ST (line 330) | pub const EM_COREA_1ST: u32 = 193;
constant EM_COREA_2ND (line 331) | pub const EM_COREA_2ND: u32 = 194;
constant EM_ARC_COMPACT2 (line 332) | pub const EM_ARC_COMPACT2: u32 = 195;
constant EM_OPEN8 (line 333) | pub const EM_OPEN8: u32 = 196;
constant EM_RL78 (line 334) | pub const EM_RL78: u32 = 197;
constant EM_VIDEOCORE5 (line 335) | pub const EM_VIDEOCORE5: u32 = 198;
constant EM_78KOR (line 336) | pub const EM_78KOR: u32 = 199;
constant EM_56800EX (line 337) | pub const EM_56800EX: u32 = 200;
constant EM_BA1 (line 338) | pub const EM_BA1: u32 = 201;
constant EM_BA2 (line 339) | pub const EM_BA2: u32 = 202;
constant EM_XCORE (line 340) | pub const EM_XCORE: u32 = 203;
constant EM_MCHP_PIC (line 341) | pub const EM_MCHP_PIC: u32 = 204;
constant EM_KM32 (line 342) | pub const EM_KM32: u32 = 210;
constant EM_KMX32 (line 343) | pub const EM_KMX32: u32 = 211;
constant EM_EMX16 (line 344) | pub const EM_EMX16: u32 = 212;
constant EM_EMX8 (line 345) | pub const EM_EMX8: u32 = 213;
constant EM_KVARC (line 346) | pub const EM_KVARC: u32 = 214;
constant EM_CDP (line 347) | pub const EM_CDP: u32 = 215;
constant EM_COGE (line 348) | pub const EM_COGE: u32 = 216;
constant EM_COOL (line 349) | pub const EM_COOL: u32 = 217;
constant EM_NORC (line 350) | pub const EM_NORC: u32 = 218;
constant EM_CSR_KALIMBA (line 351) | pub const EM_CSR_KALIMBA: u32 = 219;
constant EM_Z80 (line 352) | pub const EM_Z80: u32 = 220;
constant EM_VISIUM (line 353) | pub const EM_VISIUM: u32 = 221;
constant EM_FT32 (line 354) | pub const EM_FT32: u32 = 222;
constant EM_MOXIE (line 355) | pub const EM_MOXIE: u32 = 223;
constant EM_AMDGPU (line 356) | pub const EM_AMDGPU: u32 = 224;
constant EM_RISCV (line 357) | pub const EM_RISCV: u32 = 243;
constant EM_BPF (line 358) | pub const EM_BPF: u32 = 247;
constant EM_NUM (line 359) | pub const EM_NUM: u32 = 248;
constant EM_ARC_A5 (line 360) | pub const EM_ARC_A5: u32 = 93;
constant EM_ALPHA (line 361) | pub const EM_ALPHA: u32 = 36902;
constant EV_NONE (line 362) | pub const EV_NONE: u32 = 0;
constant EV_CURRENT (line 363) | pub const EV_CURRENT: u32 = 1;
constant EV_NUM (line 364) | pub const EV_NUM: u32 = 2;
constant SHN_UNDEF (line 365) | pub const SHN_UNDEF: u32 = 0;
constant SHN_LORESERVE (line 366) | pub const SHN_LORESERVE: u32 = 65280;
constant SHN_LOPROC (line 367) | pub const SHN_LOPROC: u32 = 65280;
constant SHN_BEFORE (line 368) | pub const SHN_BEFORE: u32 = 65280;
constant SHN_AFTER (line 369) | pub const SHN_AFTER: u32 = 65281;
constant SHN_HIPROC (line 370) | pub const SHN_HIPROC: u32 = 65311;
constant SHN_LOOS (line 371) | pub const SHN_LOOS: u32 = 65312;
constant SHN_HIOS (line 372) | pub const SHN_HIOS: u32 = 65343;
constant SHN_ABS (line 373) | pub const SHN_ABS: u32 = 65521;
constant SHN_COMMON (line 374) | pub const SHN_COMMON: u32 = 65522;
constant SHN_XINDEX (line 375) | pub const SHN_XINDEX: u32 = 65535;
constant SHN_HIRESERVE (line 376) | pub const SHN_HIRESERVE: u32 = 65535;
constant SHT_NULL (line 377) | pub const SHT_NULL: u32 = 0;
constant SHT_PROGBITS (line 378) | pub const SHT_PROGBITS: u32 = 1;
constant SHT_SYMTAB (line 379) | pub const SHT_SYMTAB: u32 = 2;
constant SHT_STRTAB (line 380) | pub const SHT_STRTAB: u32 = 3;
constant SHT_RELA (line 381) | pub const SHT_RELA: u32 = 4;
constant SHT_HASH (line 382) | pub const SHT_HASH: u32 = 5;
constant SHT_DYNAMIC (line 383) | pub const SHT_DYNAMIC: u32 = 6;
constant SHT_NOTE (line 384) | pub const SHT_NOTE: u32 = 7;
constant SHT_NOBITS (line 385) | pub const SHT_NOBITS: u32 = 8;
constant SHT_REL (line 386) | pub const SHT_REL: u32 = 9;
constant SHT_SHLIB (line 387) | pub const SHT_SHLIB: u32 = 10;
constant SHT_DYNSYM (line 388) | pub const SHT_DYNSYM: u32 = 11;
constant SHT_INIT_ARRAY (line 389) | pub const SHT_INIT_ARRAY: u32 = 14;
constant SHT_FINI_ARRAY (line 390) | pub const SHT_FINI_ARRAY: u32 = 15;
constant SHT_PREINIT_ARRAY (line 391) | pub const SHT_PREINIT_ARRAY: u32 = 16;
constant SHT_GROUP (line 392) | pub const SHT_GROUP: u32 = 17;
constant SHT_SYMTAB_SHNDX (line 393) | pub const SHT_SYMTAB_SHNDX: u32 = 18;
constant SHT_NUM (line 394) | pub const SHT_NUM: u32 = 19;
constant SHT_LOOS (line 395) | pub const SHT_LOOS: u32 = 1610612736;
constant SHT_GNU_ATTRIBUTES (line 396) | pub const SHT_GNU_ATTRIBUTES: u32 = 1879048181;
constant SHT_GNU_HASH (line 397) | pub const SHT_GNU_HASH: u32 = 1879048182;
constant SHT_GNU_LIBLIST (line 398) | pub const SHT_GNU_LIBLIST: u32 = 1879048183;
constant SHT_CHECKSUM (line 399) | pub const SHT_CHECKSUM: u32 = 1879048184;
constant SHT_LOSUNW (line 400) | pub const SHT_LOSUNW: u32 = 1879048186;
constant SHT_SUNW_move (line 401) | pub const SHT_SUNW_move: u32 = 1879048186;
constant SHT_SUNW_COMDAT (line 402) | pub const SHT_SUNW_COMDAT: u32 = 1879048187;
constant SHT_SUNW_syminfo (line 403) | pub const SHT_SUNW_syminfo: u32 = 1879048188;
constant SHT_GNU_verdef (line 404) | pub const SHT_GNU_verdef: u32 = 1879048189;
constant SHT_GNU_verneed (line 405) | pub const SHT_GNU_verneed: u32 = 1879048190;
constant SHT_GNU_versym (line 406) | pub const SHT_GNU_versym: u32 = 1879048191;
constant SHT_HISUNW (line 407) | pub const SHT_HISUNW: u32 = 1879048191;
constant SHT_HIOS (line 408) | pub const SHT_HIOS: u32 = 1879048191;
constant SHT_LOPROC (line 409) | pub const SHT_LOPROC: u32 = 1879048192;
constant SHT_HIPROC (line 410) | pub const SHT_HIPROC: u32 = 2147483647;
constant SHT_LOUSER (line 411) | pub const SHT_LOUSER: u32 = 2147483648;
constant SHT_HIUSER (line 412) | pub const SHT_HIUSER: u32 = 2415919103;
constant SHF_WRITE (line 413) | pub const SHF_WRITE: u32 = 1;
constant SHF_ALLOC (line 414) | pub const SHF_ALLOC: u32 = 2;
constant SHF_EXECINSTR (line 415) | pub const SHF_EXECINSTR: u32 = 4;
constant SHF_MERGE (line 416) | pub const SHF_MERGE: u32 = 16;
constant SHF_STRINGS (line 417) | pub const SHF_STRINGS: u32 = 32;
constant SHF_INFO_LINK (line 418) | pub const SHF_INFO_LINK: u32 = 64;
constant SHF_LINK_ORDER (line 419) | pub const SHF_LINK_ORDER: u32 = 128;
constant SHF_OS_NONCONFORMING (line 420) | pub const SHF_OS_NONCONFORMING: u32 = 256;
constant SHF_GROUP (line 421) | pub const SHF_GROUP: u32 = 512;
constant SHF_TLS (line 422) | pub const SHF_TLS: u32 = 1024;
constant SHF_COMPRESSED (line 423) | pub const SHF_COMPRESSED: u32 = 2048;
constant SHF_MASKOS (line 424) | pub const SHF_MASKOS: u32 = 267386880;
constant SHF_MASKPROC (line 425) | pub const SHF_MASKPROC: u32 = 4026531840;
constant SHF_ORDERED (line 426) | pub const SHF_ORDERED: u32 = 1073741824;
constant SHF_EXCLUDE (line 427) | pub const SHF_EXCLUDE: u32 = 2147483648;
constant ELFCOMPRESS_ZLIB (line 428) | pub const ELFCOMPRESS_ZLIB: u32 = 1;
constant ELFCOMPRESS_LOOS (line 429) | pub const ELFCOMPRESS_LOOS: u32 = 1610612736;
constant ELFCOMPRESS_HIOS (line 430) | pub const ELFCOMPRESS_HIOS: u32 = 1879048191;
constant ELFCOMPRESS_LOPROC (line 431) | pub const ELFCOMPRESS_LOPROC: u32 = 1879048192;
constant ELFCOMPRESS_HIPROC (line 432) | pub const ELFCOMPRESS_HIPROC: u32 = 2147483647;
constant GRP_COMDAT (line 433) | pub const GRP_COMDAT: u32 = 1;
constant SYMINFO_BT_SELF (line 434) | pub const SYMINFO_BT_SELF: u32 = 65535;
constant SYMINFO_BT_PARENT (line 435) | pub const SYMINFO_BT_PARENT: u32 = 65534;
constant SYMINFO_BT_LOWRESERVE (line 436) | pub const SYMINFO_BT_LOWRESERVE: u32 = 65280;
constant SYMINFO_FLG_DIRECT (line 437) | pub const SYMINFO_FLG_DIRECT: u32 = 1;
constant SYMINFO_FLG_PASSTHRU (line 438) | pub const SYMINFO_FLG_PASSTHRU: u32 = 2;
constant SYMINFO_FLG_COPY (line 439) | pub const SYMINFO_FLG_COPY: u32 = 4;
constant SYMINFO_FLG_LAZYLOAD (line 440) | pub const SYMINFO_FLG_LAZYLOAD: u32 = 8;
constant SYMINFO_NONE (line 441) | pub const SYMINFO_NONE: u32 = 0;
constant SYMINFO_CURRENT (line 442) | pub const SYMINFO_CURRENT: u32 = 1;
constant SYMINFO_NUM (line 443) | pub const SYMINFO_NUM: u32 = 2;
constant STB_LOCAL (line 444) | pub const STB_LOCAL: u32 = 0;
constant STB_GLOBAL (line 445) | pub const STB_GLOBAL: u32 = 1;
constant STB_WEAK (line 446) | pub const STB_WEAK: u32 = 2;
constant STB_NUM (line 447) | pub const STB_NUM: u32 = 3;
constant STB_LOOS (line 448) | pub const STB_LOOS: u32 = 10;
constant STB_GNU_UNIQUE (line 449) | pub const STB_GNU_UNIQUE: u32 = 10;
constant STB_HIOS (line 450) | pub const STB_HIOS: u32 = 12;
constant STB_LOPROC (line 451) | pub const STB_LOPROC: u32 = 13;
constant STB_HIPROC (line 452) | pub const STB_HIPROC: u32 = 15;
constant STT_NOTYPE (line 453) | pub const STT_NOTYPE: u32 = 0;
constant STT_OBJECT (line 454) | pub const STT_OBJECT: u32 = 1;
constant STT_FUNC (line 455) | pub const STT_FUNC: u32 = 2;
constant STT_SECTION (line 456) | pub const STT_SECTION: u32 = 3;
constant STT_FILE (line 457) | pub const STT_FILE: u32 = 4;
constant STT_COMMON (line 458) | pub const STT_COMMON: u32 = 5;
constant STT_TLS (line 459) | pub const STT_TLS: u32 = 6;
constant STT_NUM (line 460) | pub const STT_NUM: u32 = 7;
constant STT_LOOS (line 461) | pub const STT_LOOS: u32 = 10;
constant STT_GNU_IFUNC (line 462) | pub const STT_GNU_IFUNC: u32 = 10;
constant STT_HIOS (line 463) | pub const STT_HIOS: u32 = 12;
constant STT_LOPROC (line 464) | pub const STT_LOPROC: u32 = 13;
constant STT_HIPROC (line 465) | pub const STT_HIPROC: u32 = 15;
constant STN_UNDEF (line 466) | pub const STN_UNDEF: u32 = 0;
constant STV_DEFAULT (line 467) | pub const STV_DEFAULT: u32 = 0;
constant STV_INTERNAL (line 468) | pub const STV_INTERNAL: u32 = 1;
constant STV_HIDDEN (line 469) | pub const STV_HIDDEN: u32 = 2;
constant STV_PROTECTED (line 470) | pub const STV_PROTECTED: u32 = 3;
constant PN_XNUM (line 471) | pub const PN_XNUM: u32 = 65535;
constant PT_NULL (line 472) | pub const PT_NULL: u32 = 0;
constant PT_LOAD (line 473) | pub const PT_LOAD: u32 = 1;
constant PT_DYNAMIC (line 474) | pub const PT_DYNAMIC: u32 = 2;
constant PT_INTERP (line 475) | pub const PT_INTERP: u32 = 3;
constant PT_NOTE (line 476) | pub const PT_NOTE: u32 = 4;
constant PT_SHLIB (line 477) | pub const PT_SHLIB: u32 = 5;
constant PT_PHDR (line 478) | pub const PT_PHDR: u32 = 6;
constant PT_TLS (line 479) | pub const PT_TLS: u32 = 7;
constant PT_NUM (line 480) | pub const PT_NUM: u32 = 8;
constant PT_LOOS (line 481) | pub const PT_LOOS: u32 = 1610612736;
constant PT_GNU_EH_FRAME (line 482) | pub const PT_GNU_EH_FRAME: u32 = 1685382480;
constant PT_GNU_STACK (line 483) | pub const PT_GNU_STACK: u32 = 1685382481;
constant PT_GNU_RELRO (line 484) | pub const PT_GNU_RELRO: u32 = 1685382482;
constant PT_LOSUNW (line 485) | pub const PT_LOSUNW: u32 = 1879048186;
constant PT_SUNWBSS (line 486) | pub const PT_SUNWBSS: u32 = 1879048186;
constant PT_SUNWSTACK (line 487) | pub const PT_SUNWSTACK: u32 = 1879048187;
constant PT_HISUNW (line 488) | pub const PT_HISUNW: u32 = 1879048191;
constant PT_HIOS (line 489) | pub const PT_HIOS: u32 = 1879048191;
constant PT_LOPROC (line 490) | pub const PT_LOPROC: u32 = 1879048192;
constant PT_HIPROC (line 491) | pub const PT_HIPROC: u32 = 2147483647;
constant PF_X (line 492) | pub const PF_X: u32 = 1;
constant PF_W (line 493) | pub const PF_W: u32 = 2;
constant PF_R (line 494) | pub const PF_R: u32 = 4;
constant PF_MASKOS (line 495) | pub const PF_MASKOS: u32 = 267386880;
constant PF_MASKPROC (line 496) | pub const PF_MASKPROC: u32 = 4026531840;
constant NT_PRSTATUS (line 497) | pub const NT_PRSTATUS: u32 = 1;
constant NT_PRFPREG (line 498) | pub const NT_PRFPREG: u32 = 2;
constant NT_FPREGSET (line 499) | pub const NT_FPREGSET: u32 = 2;
constant NT_PRPSINFO (line 500) | pub const NT_PRPSINFO: u32 = 3;
constant NT_PRXREG (line 501) | pub const NT_PRXREG: u32 = 4;
constant NT_TASKSTRUCT (line 502) | pub const NT_TASKSTRUCT: u32 = 4;
constant NT_PLATFORM (line 503) | pub const NT_PLATFORM: u32 = 5;
constant NT_AUXV (line 504) | pub const NT_AUXV: u32 = 6;
constant NT_GWINDOWS (line 505) | pub const NT_GWINDOWS: u32 = 7;
constant NT_ASRS (line 506) | pub const NT_ASRS: u32 = 8;
constant NT_PSTATUS (line 507) | pub const NT_PSTATUS: u32 = 10;
constant NT_PSINFO (line 508) | pub const NT_PSINFO: u32 = 13;
constant NT_PRCRED (line 509) | pub const NT_PRCRED: u32 = 14;
constant NT_UTSNAME (line 510) | pub const NT_UTSNAME: u32 = 15;
constant NT_LWPSTATUS (line 511) | pub const NT_LWPSTATUS: u32 = 16;
constant NT_LWPSINFO (line 512) | pub const NT_LWPSINFO: u32 = 17;
constant NT_PRFPXREG (line 513) | pub const NT_PRFPXREG: u32 = 20;
constant NT_SIGINFO (line 514) | pub const NT_SIGINFO: u32 = 1397311305;
constant NT_FILE (line 515) | pub const NT_FILE: u32 = 1179208773;
constant NT_PRXFPREG (line 516) | pub const NT_PRXFPREG: u32 = 1189489535;
constant NT_PPC_VMX (line 517) | pub const NT_PPC_VMX: u32 = 256;
constant NT_PPC_SPE (line 518) | pub const NT_PPC_SPE: u32 = 257;
constant NT_PPC_VSX (line 519) | pub const NT_PPC_VSX: u32 = 258;
constant NT_PPC_TAR (line 520) | pub const NT_PPC_TAR: u32 = 259;
constant NT_PPC_PPR (line 521) | pub const NT_PPC_PPR: u32 = 260;
constant NT_PPC_DSCR (line 522) | pub const NT_PPC_DSCR: u32 = 261;
constant NT_PPC_EBB (line 523) | pub const NT_PPC_EBB: u32 = 262;
constant NT_PPC_PMU (line 524) | pub const NT_PPC_PMU: u32 = 263;
constant NT_PPC_TM_CGPR (line 525) | pub const NT_PPC_TM_CGPR: u32 = 264;
constant NT_PPC_TM_CFPR (line 526) | pub const NT_PPC_TM_CFPR: u32 = 265;
constant NT_PPC_TM_CVMX (line 527) | pub const NT_PPC_TM_CVMX: u32 = 266;
constant NT_PPC_TM_CVSX (line 528) | pub const NT_PPC_TM_CVSX: u32 = 267;
constant NT_PPC_TM_SPR (line 529) | pub const NT_PPC_TM_SPR: u32 = 268;
constant NT_PPC_TM_CTAR (line 530) | pub const NT_PPC_TM_CTAR: u32 = 269;
constant NT_PPC_TM_CPPR (line 531) | pub const NT_PPC_TM_CPPR: u32 = 270;
constant NT_PPC_TM_CDSCR (line 532) | pub const NT_PPC_TM_CDSCR: u32 = 271;
constant NT_PPC_PKEY (line 533) | pub const NT_PPC_PKEY: u32 = 272;
constant NT_386_TLS (line 534) | pub const NT_386_TLS: u32 = 512;
constant NT_386_IOPERM (line 535) | pub const NT_386_IOPERM: u32 = 513;
constant NT_X86_XSTATE (line 536) | pub const NT_X86_XSTATE: u32 = 514;
constant NT_S390_HIGH_GPRS (line 537) | pub const NT_S390_HIGH_GPRS: u32 = 768;
constant NT_S390_TIMER (line 538) | pub const NT_S390_TIMER: u32 = 769;
constant NT_S390_TODCMP (line 539) | pub const NT_S390_TODCMP: u32 = 770;
constant NT_S390_TODPREG (line 540) | pub const NT_S390_TODPREG: u32 = 771;
constant NT_S390_CTRS (line 541) | pub const NT_S390_CTRS: u32 = 772;
constant NT_S390_PREFIX (line 542) | pub const NT_S390_PREFIX: u32 = 773;
constant NT_S390_LAST_BREAK (line 543) | pub const NT_S390_LAST_BREAK: u32 = 774;
constant NT_S390_SYSTEM_CALL (line 544) | pub const NT_S390_SYSTEM_CALL: u32 = 775;
constant NT_S390_TDB (line 545) | pub const NT_S390_TDB: u32 = 776;
constant NT_S390_VXRS_LOW (line 546) | pub const NT_S390_VXRS_LOW: u32 = 777;
constant NT_S390_VXRS_HIGH (line 547) | pub const NT_S390_VXRS_HIGH: u32 = 778;
constant NT_S390_GS_CB (line 548) | pub const NT_S390_GS_CB: u32 = 779;
constant NT_S390_GS_BC (line 549) | pub const NT_S390_GS_BC: u32 = 780;
constant NT_S390_RI_CB (line 550) | pub const NT_S390_RI_CB: u32 = 781;
constant NT_ARM_VFP (line 551) | pub const NT_ARM_VFP: u32 = 1024;
constant NT_ARM_TLS (line 552) | pub const NT_ARM_TLS: u32 = 1025;
constant NT_ARM_HW_BREAK (line 553) | pub const NT_ARM_HW_BREAK: u32 = 1026;
constant NT_ARM_HW_WATCH (line 554) | pub const NT_ARM_HW_WATCH: u32 = 1027;
constant NT_ARM_SYSTEM_CALL (line 555) | pub const NT_ARM_SYSTEM_CALL: u32 = 1028;
constant NT_ARM_SVE (line 556) | pub const NT_ARM_SVE: u32 = 1029;
constant NT_VERSION (line 557) | pub const NT_VERSION: u32 = 1;
constant DT_NULL (line 558) | pub const DT_NULL: u32 = 0;
constant DT_NEEDED (line 559) | pub const DT_NEEDED: u32 = 1;
constant DT_PLTRELSZ (line 560) | pub const DT_PLTRELSZ: u32 = 2;
constant DT_PLTGOT (line 561) | pub const DT_PLTGOT: u32 = 3;
constant DT_HASH (line 562) | pub const DT_HASH: u32 = 4;
constant DT_STRTAB (line 563) | pub const DT_STRTAB: u32 = 5;
constant DT_SYMTAB (line 564) | pub const DT_SYMTAB: u32 = 6;
constant DT_RELA (line 565) | pub const DT_RELA: u32 = 7;
constant DT_RELASZ (line 566) | pub const DT_RELASZ: u32 = 8;
constant DT_RELAENT (line 567) | pub const DT_RELAENT: u32 = 9;
constant DT_STRSZ (line 568) | pub const DT_STRSZ: u32 = 10;
constant DT_SYMENT (line 569) | pub const DT_SYMENT: u32 = 11;
constant DT_INIT (line 570) | pub const DT_INIT: u32 = 12;
constant DT_FINI (line 571) | pub const DT_FINI: u32 = 13;
constant DT_SONAME (line 572) | pub const DT_SONAME: u32 = 14;
constant DT_RPATH (line 573) | pub const DT_RPATH: u32 = 15;
constant DT_SYMBOLIC (line 574) | pub const DT_SYMBOLIC: u32 = 16;
constant DT_REL (line 575) | pub const DT_REL: u32 = 17;
constant DT_RELSZ (line 576) | pub const DT_RELSZ: u32 = 18;
constant DT_RELENT (line 577) | pub const DT_RELENT: u32 = 19;
constant DT_PLTREL (line 578) | pub const DT_PLTREL: u32 = 20;
constant DT_DEBUG (line 579) | pub const DT_DEBUG: u32 = 21;
constant DT_TEXTREL (line 580) | pub const DT_TEXTREL: u32 = 22;
constant DT_JMPREL (line 581) | pub const DT_JMPREL: u32 = 23;
constant DT_BIND_NOW (line 582) | pub const DT_BIND_NOW: u32 = 24;
constant DT_INIT_ARRAY (line 583) | pub const DT_INIT_ARRAY: u32 = 25;
constant DT_FINI_ARRAY (line 584) | pub const DT_FINI_ARRAY: u32 = 26;
constant DT_INIT_ARRAYSZ (line 585) | pub const DT_INIT_ARRAYSZ: u32 = 27;
constant DT_FINI_ARRAYSZ (line 586) | pub const DT_FINI_ARRAYSZ: u32 = 28;
constant DT_RUNPATH (line 587) | pub const DT_RUNPATH: u32 = 29;
constant DT_FLAGS (line 588) | pub const DT_FLAGS: u32 = 30;
constant DT_ENCODING (line 589) | pub const DT_ENCODING: u32 = 32;
constant DT_PREINIT_ARRAY (line 590) | pub const DT_PREINIT_ARRAY: u32 = 32;
constant DT_PREINIT_ARRAYSZ (line 591) | pub const DT_PREINIT_ARRAYSZ: u32 = 33;
constant DT_SYMTAB_SHNDX (line 592) | pub const DT_SYMTAB_SHNDX: u32 = 34;
constant DT_NUM (line 593) | pub const DT_NUM: u32 = 35;
constant DT_LOOS (line 594) | pub const DT_LOOS: u32 = 1610612749;
constant DT_HIOS (line 595) | pub const DT_HIOS: u32 = 1879044096;
constant DT_LOPROC (line 596) | pub const DT_LOPROC: u32 = 1879048192;
constant DT_HIPROC (line 597) | pub const DT_HIPROC: u32 = 2147483647;
constant DT_VALRNGLO (line 598) | pub const DT_VALRNGLO: u32 = 1879047424;
constant DT_GNU_PRELINKED (line 599) | pub const DT_GNU_PRELINKED: u32 = 1879047669;
constant DT_GNU_CONFLICTSZ (line 600) | pub const DT_GNU_CONFLICTSZ: u32 = 1879047670;
constant DT_GNU_LIBLISTSZ (line 601) | pub const DT_GNU_LIBLISTSZ: u32 = 1879047671;
constant DT_CHECKSUM (line 602) | pub const DT_CHECKSUM: u32 = 1879047672;
constant DT_PLTPADSZ (line 603) | pub const DT_PLTPADSZ: u32 = 1879047673;
constant DT_MOVEENT (line 604) | pub const DT_MOVEENT: u32 = 1879047674;
constant DT_MOVESZ (line 605) | pub const DT_MOVESZ: u32 = 1879047675;
constant DT_FEATURE_1 (line 606) | pub const DT_FEATURE_1: u32 = 1879047676;
constant DT_POSFLAG_1 (line 607) | pub const DT_POSFLAG_1: u32 = 1879047677;
constant DT_SYMINSZ (line 608) | pub const DT_SYMINSZ: u32 = 1879047678;
constant DT_SYMINENT (line 609) | pub const DT_SYMINENT: u32 = 1879047679;
constant DT_VALRNGHI (line 610) | pub const DT_VALRNGHI: u32 = 1879047679;
constant DT_VALNUM (line 611) | pub const DT_VALNUM: u32 = 12;
constant DT_ADDRRNGLO (line 612) | pub const DT_ADDRRNGLO: u32 = 1879047680;
constant DT_GNU_HASH (line 613) | pub const DT_GNU_HASH: u32 = 1879047925;
constant DT_TLSDESC_PLT (line 614) | pub const DT_TLSDESC_PLT: u32 = 1879047926;
constant DT_TLSDESC_GOT (line 615) | pub const DT_TLSDESC_GOT: u32 = 1879047927;
constant DT_GNU_CONFLICT (line 616) | pub const DT_GNU_CONFLICT: u32 = 1879047928;
constant DT_GNU_LIBLIST (line 617) | pub const DT_GNU_LIBLIST: u32 = 1879047929;
constant DT_CONFIG (line 618) | pub const DT_CONFIG: u32 = 1879047930;
constant DT_DEPAUDIT (line 619) | pub const DT_DEPAUDIT: u32 = 1879047931;
constant DT_AUDIT (line 620) | pub const DT_AUDIT: u32 = 1879047932;
constant DT_PLTPAD (line 621) | pub const DT_PLTPAD: u32 = 1879047933;
constant DT_MOVETAB (line 622) | pub const DT_MOVETAB: u32 = 1879047934;
constant DT_SYMINFO (line 623) | pub const DT_SYMINFO: u32 = 1879047935;
constant DT_ADDRRNGHI (line 624) | pub const DT_ADDRRNGHI: u32 = 1879047935;
constant DT_ADDRNUM (line 625) | pub const DT_ADDRNUM: u32 = 11;
constant DT_VERSYM (line 626) | pub const DT_VERSYM: u32 = 1879048176;
constant DT_RELACOUNT (line 627) | pub const DT_RELACOUNT: u32 = 1879048185;
constant DT_RELCOUNT (line 628) | pub const DT_RELCOUNT: u32 = 1879048186;
constant DT_FLAGS_1 (line 629) | pub const DT_FLAGS_1: u32 = 1879048187;
constant DT_VERDEF (line 630) | pub const DT_VERDEF: u32 = 1879048188;
constant DT_VERDEFNUM (line 631) | pub const DT_VERDEFNUM: u32 = 1879048189;
constant DT_VERNEED (line 632) | pub const DT_VERNEED: u32 = 1879048190;
constant DT_VERNEEDNUM (line 633) | pub const DT_VERNEEDNUM: u32 = 1879048191;
constant DT_VERSIONTAGNUM (line 634) | pub const DT_VERSIONTAGNUM: u32 = 16;
constant DT_AUXILIARY (line 635) | pub const DT_AUXILIARY: u32 = 2147483645;
constant DT_FILTER (line 636) | pub const DT_FILTER: u32 = 2147483647;
constant DT_EXTRANUM (line 637) | pub const DT_EXTRANUM: u32 = 3;
constant DF_ORIGIN (line 638) | pub const DF_ORIGIN: u32 = 1;
constant DF_SYMBOLIC (line 639) | pub const DF_SYMBOLIC: u32 = 2;
constant DF_TEXTREL (line 640) | pub const DF_TEXTREL: u32 = 4;
constant DF_BIND_NOW (line 641) | pub const DF_BIND_NOW: u32 = 8;
constant DF_STATIC_TLS (line 642) | pub const DF_STATIC_TLS: u32 = 16;
constant DF_1_NOW (line 643) | pub const DF_1_NOW: u32 = 1;
constant DF_1_GLOBAL (line 644) | pub const DF_1_GLOBAL: u32 = 2;
constant DF_1_GROUP (line 645) | pub const DF_1_GROUP: u32 = 4;
constant DF_1_NODELETE (line 646) | pub const DF_1_NODELETE: u32 = 8;
constant DF_1_LOADFLTR (line 647) | pub const DF_1_LOADFLTR: u32 = 16;
constant DF_1_INITFIRST (line 648) | pub const DF_1_INITFIRST: u32 = 32;
constant DF_1_NOOPEN (line 649) | pub const DF_1_NOOPEN: u32 = 64;
constant DF_1_ORIGIN (line 650) | pub const DF_1_ORIGIN: u32 = 128;
constant DF_1_DIRECT (line 651) | pub const DF_1_DIRECT: u32 = 256;
constant DF_1_TRANS (line 652) | pub const DF_1_TRANS: u32 = 512;
constant DF_1_INTERPOSE (line 653) | pub const DF_1_INTERPOSE: u32 = 1024;
constant DF_1_NODEFLIB (line 654) | pub const DF_1_NODEFLIB: u32 = 2048;
constant DF_1_NODUMP (line 655) | pub const DF_1_NODUMP: u32 = 4096;
constant DF_1_CONFALT (line 656) | pub const DF_1_CONFALT: u32 = 8192;
constant DF_1_ENDFILTEE (line 657) | pub const DF_1_ENDFILTEE: u32 = 16384;
constant DF_1_DISPRELDNE (line 658) | pub const DF_1_DISPRELDNE: u32 = 32768;
constant DF_1_DISPRELPND (line 659) | pub const DF_1_DISPRELPND: u32 = 65536;
constant DF_1_NODIRECT (line 660) | pub const DF_1_NODIRECT: u32 = 131072;
constant DF_1_IGNMULDEF (line 661) | pub const DF_1_IGNMULDEF: u32 = 262144;
constant DF_1_NOKSYMS (line 662) | pub const DF_1_NOKSYMS: u32 = 524288;
constant DF_1_NOHDR (line 663) | pub const DF_1_NOHDR: u32 = 1048576;
constant DF_1_EDITED (line 664) | pub const DF_1_EDITED: u32 = 2097152;
constant DF_1_NORELOC (line 665) | pub const DF_1_NORELOC: u32 = 4194304;
constant DF_1_SYMINTPOSE (line 666) | pub const DF_1_SYMINTPOSE: u32 = 8388608;
constant DF_1_GLOBAUDIT (line 667) | pub const DF_1_GLOBAUDIT: u32 = 16777216;
constant DF_1_SINGLETON (line 668) | pub const DF_1_SINGLETON: u32 = 33554432;
constant DF_1_STUB (line 669) | pub const DF_1_STUB: u32 = 67108864;
constant DF_1_PIE (line 670) | pub const DF_1_PIE: u32 = 134217728;
constant DTF_1_PARINIT (line 671) | pub const DTF_1_PARINIT: u32 = 1;
constant DTF_1_CONFEXP (line 672) | pub const DTF_1_CONFEXP: u32 = 2;
constant DF_P1_LAZYLOAD (line 673) | pub const DF_P1_LAZYLOAD: u32 = 1;
constant DF_P1_GROUPPERM (line 674) | pub const DF_P1_GROUPPERM: u32 = 2;
constant VER_DEF_NONE (line 675) | pub const VER_DEF_NONE: u32 = 0;
constant VER_DEF_CURRENT (line 676) | pub const VER_DEF_CURRENT: u32 = 1;
constant VER_DEF_NUM (line 677) | pub const VER_DEF_NUM: u32 = 2;
constant VER_FLG_BASE (line 678) | pub const VER_FLG_BASE: u32 = 1;
constant VER_FLG_WEAK (line 679) | pub const VER_FLG_WEAK: u32 = 2;
constant VER_NDX_LOCAL (line 680) | pub const VER_NDX_LOCAL: u32 = 0;
constant VER_NDX_GLOBAL (line 681) | pub const VER_NDX_GLOBAL: u32 = 1;
constant VER_NDX_LORESERVE (line 682) | pub const VER_NDX_LORESERVE: u32 = 65280;
constant VER_NDX_ELIMINATE (line 683) | pub const VER_NDX_ELIMINATE: u32 = 65281;
constant VER_NEED_NONE (line 684) | pub const VER_NEED_NONE: u32 = 0;
constant VER_NEED_CURRENT (line 685) | pub const VER_NEED_CURRENT: u32 = 1;
constant VER_NEED_NUM (line 686) | pub const VER_NEED_NUM: u32 = 2;
constant AT_NULL (line 687) | pub const AT_NULL: u32 = 0;
constant AT_IGNORE (line 688) | pub const AT_IGNORE: u32 = 1;
constant AT_EXECFD (line 689) | pub const AT_EXECFD: u32 = 2;
constant AT_PHDR (line 690) | pub const AT_PHDR: u32 = 3;
constant AT_PHENT (line 691) | pub const AT_PHENT: u32 = 4;
constant AT_PHNUM (line 692) | pub const AT_PHNUM: u32 = 5;
constant AT_PAGESZ (line 693) | pub const AT_PAGESZ: u32 = 6;
constant AT_BASE (line 694) | pub const AT_BASE: u32 = 7;
constant AT_FLAGS (line 695) | pub const AT_FLAGS: u32 = 8;
constant AT_ENTRY (line 696) | pub const AT_ENTRY: u32 = 9;
constant AT_NOTELF (line 697) | pub const AT_NOTELF: u32 = 10;
constant AT_UID (line 698) | pub const AT_UID: u32 = 11;
constant AT_EUID (line 699) | pub const AT_EUID: u32 = 12;
constant AT_GID (line 700) | pub const AT_GID: u32 = 13;
constant AT_EGID (line 701) | pub const AT_EGID: u32 = 14;
constant AT_CLKTCK (line 702) | pub const AT_CLKTCK: u32 = 17;
constant AT_PLATFORM (line 703) | pub const AT_PLATFORM: u32 = 15;
constant AT_HWCAP (line 704) | pub const AT_HWCAP: u32 = 16;
constant AT_FPUCW (line 705) | pub const AT_FPUCW: u32 = 18;
constant AT_DCACHEBSIZE (line 706) | pub const AT_DCACHEBSIZE: u32 = 19;
constant AT_ICACHEBSIZE (line 707) | pub const AT_ICACHEBSIZE: u32 = 20;
constant AT_UCACHEBSIZE (line 708) | pub const AT_UCACHEBSIZE: u32 = 21;
constant AT_IGNOREPPC (line 709) | pub const AT_IGNOREPPC: u32 = 22;
constant AT_SECURE (line 710) | pub const AT_SECURE: u32 = 23;
constant AT_BASE_PLATFORM (line 711) | pub const AT_BASE_PLATFORM: u32 = 24;
constant AT_RANDOM (line 712) | pub const AT_RANDOM: u32 = 25;
constant AT_HWCAP2 (line 713) | pub const AT_HWCAP2: u32 = 26;
constant AT_EXECFN (line 714) | pub const AT_EXECFN: u32 = 31;
constant AT_SYSINFO (line 715) | pub const AT_SYSINFO: u32 = 32;
constant AT_SYSINFO_EHDR (line 716) | pub const AT_SYSINFO_EHDR: u32 = 33;
constant AT_L1I_CACHESHAPE (line 717) | pub const AT_L1I_CACHESHAPE: u32 = 34;
constant AT_L1D_CACHESHAPE (line 718) | pub const AT_L1D_CACHESHAPE: u32 = 35;
constant AT_L2_CACHESHAPE (line 719) | pub const AT_L2_CACHESHAPE: u32 = 36;
constant AT_L3_CACHESHAPE (line 720) | pub const AT_L3_CACHESHAPE: u32 = 37;
constant AT_L1I_CACHESIZE (line 721) | pub const AT_L1I_CACHESIZE: u32 = 40;
constant AT_L1I_CACHEGEOMETRY (line 722) | pub const AT_L1I_CACHEGEOMETRY: u32 = 41;
constant AT_L1D_CACHESIZE (line 723) | pub const AT_L1D_CACHESIZE: u32 = 42;
constant AT_L1D_CACHEGEOMETRY (line 724) | pub const AT_L1D_CACHEGEOMETRY: u32 = 43;
constant AT_L2_CACHESIZE (line 725) | pub const AT_L2_CACHESIZE: u32 = 44;
constant AT_L2_CACHEGEOMETRY (line 726) | pub const AT_L2_CACHEGEOMETRY: u32 = 45;
constant AT_L3_CACHESIZE (line 727) | pub const AT_L3_CACHESIZE: u32 = 46;
constant AT_L3_CACHEGEOMETRY (line 728) | pub const AT_L3_CACHEGEOMETRY: u32 = 47;
constant ELF_NOTE_SOLARIS (line 729) | pub const ELF_NOTE_SOLARIS: &'static [u8; 13usize] = b"SUNW Solaris\0";
constant ELF_NOTE_GNU (line 730) | pub const ELF_NOTE_GNU: &'static [u8; 4usize] = b"GNU\0";
constant ELF_NOTE_PAGESIZE_HINT (line 731) | pub const ELF_NOTE_PAGESIZE_HINT: u32 = 1;
constant NT_GNU_ABI_TAG (line 732) | pub const NT_GNU_ABI_TAG: u32 = 1;
constant ELF_NOTE_ABI (line 733) | pub const ELF_NOTE_ABI: u32 = 1;
constant ELF_NOTE_OS_LINUX (line 734) | pub const ELF_NOTE_OS_LINUX: u32 = 0;
constant ELF_NOTE_OS_GNU (line 735) | pub const ELF_NOTE_OS_GNU: u32 = 1;
constant ELF_NOTE_OS_SOLARIS2 (line 736) | pub const ELF_NOTE_OS_SOLARIS2: u32 = 2;
constant ELF_NOTE_OS_FREEBSD (line 737) | pub const ELF_NOTE_OS_FREEBSD: u32 = 3;
constant NT_GNU_HWCAP (line 738) | pub const NT_GNU_HWCAP: u32 = 2;
constant NT_GNU_BUILD_ID (line 739) | pub const NT_GNU_BUILD_ID: u32 = 3;
constant NT_GNU_GOLD_VERSION (line 740) | pub const NT_GNU_GOLD_VERSION: u32 = 4;
constant NT_GNU_PROPERTY_TYPE_0 (line 741) | pub const NT_GNU_PROPERTY_TYPE_0: u32 = 5;
constant NOTE_GNU_PROPERTY_SECTION_NAME (line 742) | pub const NOTE_GNU_PROPERTY_SECTION_NAME: &'static [u8; 19usize] = b".no...
constant GNU_PROPERTY_STACK_SIZE (line 743) | pub const GNU_PROPERTY_STACK_SIZE: u32 = 1;
constant GNU_PROPERTY_NO_COPY_ON_PROTECTED (line 744) | pub const GNU_PROPERTY_NO_COPY_ON_PROTECTED: u32 = 2;
constant GNU_PROPERTY_LOPROC (line 745) | pub const GNU_PROPERTY_LOPROC: u32 = 3221225472;
constant GNU_PROPERTY_HIPROC (line 746) | pub const GNU_PROPERTY_HIPROC: u32 = 3758096383;
constant GNU_PROPERTY_LOUSER (line 747) | pub const GNU_PROPERTY_LOUSER: u32 = 3758096384;
constant GNU_PROPERTY_HIUSER (line 748) | pub const GNU_PROPERTY_HIUSER: u32 = 4294967295;
constant GNU_PROPERTY_X86_ISA_1_USED (line 749) | pub const GNU_PROPERTY_X86_ISA_1_USED: u32 = 3221225472;
constant GNU_PROPERTY_X86_ISA_1_NEEDED (line 750) | pub const GNU_PROPERTY_X86_ISA_1_NEEDED: u32 = 3221225473;
constant GNU_PROPERTY_X86_FEATURE_1_AND (line 751) | pub const GNU_PROPERTY_X86_FEATURE_1_AND: u32 = 3221225474;
constant GNU_PROPERTY_X86_ISA_1_486 (line 752) | pub const GNU_PROPERTY_X86_ISA_1_486: u32 = 1;
constant GNU_PROPERTY_X86_ISA_1_586 (line 753) | pub const GNU_PROPERTY_X86_ISA_1_586: u32 = 2;
constant GNU_PROPERTY_X86_ISA_1_686 (line 754) | pub const GNU_PROPERTY_X86_ISA_1_686: u32 = 4;
constant GNU_PROPERTY_X86_ISA_1_SSE (line 755) | pub const GNU_PROPERTY_X86_ISA_1_SSE: u32 = 8;
constant GNU_PROPERTY_X86_ISA_1_SSE2 (line 756) | pub const GNU_PROPERTY_X86_ISA_1_SSE2: u32 = 16;
constant GNU_PROPERTY_X86_ISA_1_SSE3 (line 757) | pub const GNU_PROPERTY_X86_ISA_1_SSE3: u32 = 32;
constant GNU_PROPERTY_X86_ISA_1_SSSE3 (line 758) | pub const GNU_PROPERTY_X86_ISA_1_SSSE3: u32 = 64;
constant GNU_PROPERTY_X86_ISA_1_SSE4_1 (line 759) | pub const GNU_PROPERTY_X86_ISA_1_SSE4_1: u32 = 128;
constant GNU_PROPERTY_X86_ISA_1_SSE4_2 (line 760) | pub const GNU_PROPERTY_X86_ISA_1_SSE4_2: u32 = 256;
constant GNU_PROPERTY_X86_ISA_1_AVX (line 761) | pub const GNU_PROPERTY_X86_ISA_1_AVX: u32 = 512;
constant GNU_PROPERTY_X86_ISA_1_AVX2 (line 762) | pub const GNU_PROPERTY_X86_ISA_1_AVX2: u32 = 1024;
constant GNU_PROPERTY_X86_ISA_1_AVX512F (line 763) | pub const GNU_PROPERTY_X86_ISA_1_AVX512F: u32 = 2048;
constant GNU_PROPERTY_X86_ISA_1_AVX512CD (line 764) | pub const GNU_PROPERTY_X86_ISA_1_AVX512CD: u32 = 4096;
constant GNU_PROPERTY_X86_ISA_1_AVX512ER (line 765) | pub const GNU_PROPERTY_X86_ISA_1_AVX512ER: u32 = 8192;
constant GNU_PROPERTY_X86_ISA_1_AVX512PF (line 766) | pub const GNU_PROPERTY_X86_ISA_1_AVX512PF: u32 = 16384;
constant GNU_PROPERTY_X86_ISA_1_AVX512VL (line 767) | pub const GNU_PROPERTY_X86_ISA_1_AVX512VL: u32 = 32768;
constant GNU_PROPERTY_X86_ISA_1_AVX512DQ (line 768) | pub const GNU_PROPERTY_X86_ISA_1_AVX512DQ: u32 = 65536;
constant GNU_PROPERTY_X86_ISA_1_AVX512BW (line 769) | pub const GNU_PROPERTY_X86_ISA_1_AVX512BW: u32 = 131072;
constant GNU_PROPERTY_X86_FEATURE_1_IBT (line 770) | pub const GNU_PROPERTY_X86_FEATURE_1_IBT: u32 = 1;
constant GNU_PROPERTY_X86_FEATURE_1_SHSTK (line 771) | pub const GNU_PROPERTY_X86_FEATURE_1_SHSTK: u32 = 2;
constant EF_CPU32 (line 772) | pub const EF_CPU32: u32 = 8454144;
constant R_68K_NONE (line 773) | pub const R_68K_NONE: u32 = 0;
constant R_68K_32 (line 774) | pub const R_68K_32: u32 = 1;
constant R_68K_16 (line 775) | pub const R_68K_16: u32 = 2;
constant R_68K_8 (line 776) | pub const R_68K_8: u32 = 3;
constant R_68K_PC32 (line 777) | pub const R_68K_PC32: u32 = 4;
constant R_68K_PC16 (line 778) | pub const R_68K_PC16: u32 = 5;
constant R_68K_PC8 (line 779) | pub const R_68K_PC8: u32 = 6;
constant R_68K_GOT32 (line 780) | pub const R_68K_GOT32: u32 = 7;
constant R_68K_GOT16 (line 781) | pub const R_68K_GOT16: u32 = 8;
constant R_68K_GOT8 (line 782) | pub const R_68K_GOT8: u32 = 9;
constant R_68K_GOT32O (line 783) | pub const R_68K_GOT32O: u32 = 10;
constant R_68K_GOT16O (line 784) | pub const R_68K_GOT16O: u32 = 11;
constant R_68K_GOT8O (line 785) | pub const R_68K_GOT8O: u32 = 12;
constant R_68K_PLT32 (line 786) | pub const R_68K_PLT32: u32 = 13;
constant R_68K_PLT16 (line 787) | pub const R_68K_PLT16: u32 = 14;
constant R_68K_PLT8 (line 788) | pub const R_68K_PLT8: u32 = 15;
constant R_68K_PLT32O (line 789) | pub const R_68K_PLT32O: u32 = 16;
constant R_68K_PLT16O (line 790) | pub const R_68K_PLT16O: u32 = 17;
constant R_68K_PLT8O (line 791) | pub const R_68K_PLT8O: u32 = 18;
constant R_68K_COPY (line 792) | pub const R_68K_COPY: u32 = 19;
constant R_68K_GLOB_DAT (line 793) | pub const R_68K_GLOB_DAT: u32 = 20;
constant R_68K_JMP_SLOT (line 794) | pub const R_68K_JMP_SLOT: u32 = 21;
constant R_68K_RELATIVE (line 795) | pub const R_68K_RELATIVE: u32 = 22;
constant R_68K_TLS_GD32 (line 796) | pub const R_68K_TLS_GD32: u32 = 25;
constant R_68K_TLS_GD16 (line 797) | pub const R_68K_TLS_GD16: u32 = 26;
constant R_68K_TLS_GD8 (line 798) | pub const R_68K_TLS_GD8: u32 = 27;
constant R_68K_TLS_LDM32 (line 799) | pub const R_68K_TLS_LDM32: u32 = 28;
constant R_68K_TLS_LDM16 (line 800) | pub const R_68K_TLS_LDM16: u32 = 29;
constant R_68K_TLS_LDM8 (line 801) | pub const R_68K_TLS_LDM8: u32 = 30;
constant R_68K_TLS_LDO32 (line 802) | pub const R_68K_TLS_LDO32: u32 = 31;
constant R_68K_TLS_LDO16 (line 803) | pub const R_68K_TLS_LDO16: u32 = 32;
constant R_68K_TLS_LDO8 (line 804) | pub const R_68K_TLS_LDO8: u32 = 33;
constant R_68K_TLS_IE32 (line 805) | pub const R_68K_TLS_IE32: u32 = 34;
constant R_68K_TLS_IE16 (line 806) | pub const R_68K_TLS_IE16: u32 = 35;
constant R_68K_TLS_IE8 (line 807) | pub const R_68K_TLS_IE8: u32 = 36;
constant R_68K_TLS_LE32 (line 808) | pub const R_68K_TLS_LE32: u32 = 37;
constant R_68K_TLS_LE16 (line 809) | pub const R_68K_TLS_LE16: u32 = 38;
constant R_68K_TLS_LE8 (line 810) | pub const R_68K_TLS_LE8: u32 = 39;
constant R_68K_TLS_DTPMOD32 (line 811) | pub const R_68K_TLS_DTPMOD32: u32 = 40;
constant R_68K_TLS_DTPREL32 (line 812) | pub const R_68K_TLS_DTPREL32: u32 = 41;
constant R_68K_TLS_TPREL32 (line 813) | pub const R_68K_TLS_TPREL32: u32 = 42;
constant R_68K_NUM (line 814) | pub const R_68K_NUM: u32 = 43;
constant R_386_NONE (line 815) | pub const R_386_NONE: u32 = 0;
constant R_386_32 (line 816) | pub const R_386_32: u32 = 1;
constant R_386_PC32 (line 817) | pub const R_386_PC32: u32 = 2;
constant R_386_GOT32 (line 818) | pub const R_386_GOT32: u32 = 3;
constant R_386_PLT32 (line 819) | pub const R_386_PLT32: u32 = 4;
constant R_386_COPY (line 820) | pub const R_386_COPY: u32 = 5;
constant R_386_GLOB_DAT (line 821) | pub const R_386_GLOB_DAT: u32 = 6;
constant R_386_JMP_SLOT (line 822) | pub const R_386_JMP_SLOT: u32 = 7;
constant R_386_RELATIVE (line 823) | pub const R_386_RELATIVE: u32 = 8;
constant R_386_GOTOFF (line 824) | pub const R_386_GOTOFF: u32 = 9;
constant R_386_GOTPC (line 825) | pub const R_386_GOTPC: u32 = 10;
constant R_386_32PLT (line 826) | pub const R_386_32PLT: u32 = 11;
constant R_386_TLS_TPOFF (line 827) | pub const R_386_TLS_TPOFF: u32 = 14;
constant R_386_TLS_IE (line 828) | pub const R_386_TLS_IE: u32 = 15;
constant R_386_TLS_GOTIE (line 829) | pub const R_386_TLS_GOTIE: u32 = 16;
constant R_386_TLS_LE (line 830) | pub const R_386_TLS_LE: u32 = 17;
constant R_386_TLS_GD (line 831) | pub const R_386_TLS_GD: u32 = 18;
constant R_386_TLS_LDM (line 832) | pub const R_386_TLS_LDM: u32 = 19;
constant R_386_16 (line 833) | pub const R_386_16: u32 = 20;
constant R_386_PC16 (line 834) | pub const R_386_PC16: u32 = 21;
constant R_386_8 (line 835) | pub const R_386_8: u32 = 22;
constant R_386_PC8 (line 836) | pub const R_386_PC8: u32 = 23;
constant R_386_TLS_GD_32 (line 837) | pub const R_386_TLS_GD_32: u32 = 24;
constant R_386_TLS_GD_PUSH (line 838) | pub const R_386_TLS_GD_PUSH: u32 = 25;
constant R_386_TLS_GD_CALL (line 839) | pub const R_386_TLS_GD_CALL: u32 = 26;
constant R_386_TLS_GD_POP (line 840) | pub const R_386_TLS_GD_POP: u32 = 27;
constant R_386_TLS_LDM_32 (line 841) | pub const R_386_TLS_LDM_32: u32 = 28;
constant R_386_TLS_LDM_PUSH (line 842) | pub const R_386_TLS_LDM_PUSH: u32 = 29;
constant R_386_TLS_LDM_CALL (line 843) | pub const R_386_TLS_LDM_CALL: u32 = 30;
constant R_386_TLS_LDM_POP (line 844) | pub const R_386_TLS_LDM_POP: u32 = 31;
constant R_386_TLS_LDO_32 (line 845) | pub const R_386_TLS_LDO_32: u32 = 32;
constant R_386_TLS_IE_32 (line 846) | pub const R_386_TLS_IE_32: u32 = 33;
constant R_386_TLS_LE_32 (line 847) | pub const R_386_TLS_LE_32: u32 = 34;
constant R_386_TLS_DTPMOD32 (line 848) | pub const R_386_TLS_DTPMOD32: u32 = 35;
constant R_386_TLS_DTPOFF32 (line 849) | pub const R_386_TLS_DTPOFF32: u32 = 36;
constant R_386_TLS_TPOFF32 (line 850) | pub const R_386_TLS_TPOFF32: u32 = 37;
constant R_386_SIZE32 (line 851) | pub const R_386_SIZE32: u32 = 38;
constant R_386_TLS_GOTDESC (line 852) | pub const R_386_TLS_GOTDESC: u32 = 39;
constant R_386_TLS_DESC_CALL (line 853) | pub const R_386_TLS_DESC_CALL: u32 = 40;
constant R_386_TLS_DESC (line 854) | pub const R_386_TLS_DESC: u32 = 41;
constant R_386_IRELATIVE (line 855) | pub const R_386_IRELATIVE: u32 = 42;
constant R_386_GOT32X (line 856) | pub const R_386_GOT32X: u32 = 43;
constant R_386_NUM (line 857) | pub const R_386_NUM: u32 = 44;
constant STT_SPARC_REGISTER (line 858) | pub const STT_SPARC_REGISTER: u32 = 13;
constant EF_SPARCV9_MM (line 859) | pub const EF_SPARCV9_MM: u32 = 3;
constant EF_SPARCV9_TSO (line 860) | pub const EF_SPARCV9_TSO: u32 = 0;
constant EF_SPARCV9_PSO (line 861) | pub const EF_SPARCV9_PSO: u32 = 1;
constant EF_SPARCV9_RMO (line 862) | pub const EF_SPARCV9_RMO: u32 = 2;
constant EF_SPARC_LEDATA (line 863) | pub const EF_SPARC_LEDATA: u32 = 8388608;
constant EF_SPARC_EXT_MASK (line 864) | pub const EF_SPARC_EXT_MASK: u32 = 16776960;
constant EF_SPARC_32PLUS (line 865) | pub const EF_SPARC_32PLUS: u32 = 256;
constant EF_SPARC_SUN_US1 (line 866) | pub const EF_SPARC_SUN_US1: u32 = 512;
constant EF_SPARC_HAL_R1 (line 867) | pub const EF_SPARC_HAL_R1: u32 = 1024;
constant EF_SPARC_SUN_US3 (line 868) | pub const EF_SPARC_SUN_US3: u32 = 2048;
constant R_SPARC_NONE (line 869) | pub const R_SPARC_NONE: u32 = 0;
constant R_SPARC_8 (line 870) | pub const R_SPARC_8: u32 = 1;
constant R_SPARC_16 (line 871) | pub const R_SPARC_16: u32 = 2;
constant R_SPARC_32 (line 872) | pub const R_SPARC_32: u32 = 3;
constant R_SPARC_DISP8 (line 873) | pub const R_SPARC_DISP8: u32 = 4;
constant R_SPARC_DISP16 (line 874) | pub const R_SPARC_DISP16: u32 = 5;
constant R_SPARC_DISP32 (line 875) | pub const R_SPARC_DISP32: u32 = 6;
constant R_SPARC_WDISP30 (line 876) | pub const R_SPARC_WDISP30: u32 = 7;
constant R_SPARC_WDISP22 (line 877) | pub const R_SPARC_WDISP22: u32 = 8;
constant R_SPARC_HI22 (line 878) | pub const R_SPARC_HI22: u32 = 9;
constant R_SPARC_22 (line 879) | pub const R_SPARC_22: u32 = 10;
constant R_SPARC_13 (line 880) | pub const R_SPARC_13: u32 = 11;
constant R_SPARC_LO10 (line 881) | pub const R_SPARC_LO10: u32 = 12;
constant R_SPARC_GOT10 (line 882) | pub const R_SPARC_GOT10: u32 = 13;
constant R_SPARC_GOT13 (line 883) | pub const R_SPARC_GOT13: u32 = 14;
constant R_SPARC_GOT22 (line 884) | pub const R_SPARC_GOT22: u32 = 15;
constant R_SPARC_PC10 (line 885) | pub const R_SPARC_PC10: u32 = 16;
constant R_SPARC_PC22 (line 886) | pub const R_SPARC_PC22: u32 = 17;
constant R_SPARC_WPLT30 (line 887) | pub const R_SPARC_WPLT30: u32 = 18;
constant R_SPARC_COPY (line 888) | pub const R_SPARC_COPY: u32 = 19;
constant R_SPARC_GLOB_DAT (line 889) | pub const R_SPARC_GLOB_DAT: u32 = 20;
constant R_SPARC_JMP_SLOT (line 890) | pub const R_SPARC_JMP_SLOT: u32 = 21;
constant R_SPARC_RELATIVE (line 891) | pub const R_SPARC_RELATIVE: u32 = 22;
constant R_SPARC_UA32 (line 892) | pub const R_SPARC_UA32: u32 = 23;
constant R_SPARC_PLT32 (line 893) | pub const R_SPARC_PLT32: u32 = 24;
constant R_SPARC_HIPLT22 (line 894) | pub const R_SPARC_HIPLT22: u32 = 25;
constant R_SPARC_LOPLT10 (line 895) | pub const R_SPARC_LOPLT10: u32 = 26;
constant R_SPARC_PCPLT32 (line 896) | pub const R_SPARC_PCPLT32: u32 = 27;
constant R_SPARC_PCPLT22 (line 897) | pub const R_SPARC_PCPLT22: u32 = 28;
constant R_SPARC_PCPLT10 (line 898) | pub const R_SPARC_PCPLT10: u32 = 29;
constant R_SPARC_10 (line 899) | pub const R_SPARC_10: u32 = 30;
constant R_SPARC_11 (line 900) | pub const R_SPARC_11: u32 = 31;
constant R_SPARC_64 (line 901) | pub const R_SPARC_64: u32 = 32;
constant R_SPARC_OLO10 (line 902) | pub const R_SPARC_OLO10: u32 = 33;
constant R_SPARC_HH22 (line 903) | pub const R_SPARC_HH22: u32 = 34;
constant R_SPARC_HM10 (line 904) | pub const R_SPARC_HM10: u32 = 35;
constant R_SPARC_LM22 (line 905) | pub const R_SPARC_LM22: u32 = 36;
constant R_SPARC_PC_HH22 (line 906) | pub const R_SPARC_PC_HH22: u32 = 37;
constant R_SPARC_PC_HM10 (line 907) | pub const R_SPARC_PC_HM10: u32 = 38;
constant R_SPARC_PC_LM22 (line 908) | pub const R_SPARC_PC_LM22: u32 = 39;
constant R_SPARC_WDISP16 (line 909) | pub const R_SPARC_WDISP16: u32 = 40;
constant R_SPARC_WDISP19 (line 910) | pub const R_SPARC_WDISP19: u32 = 41;
constant R_SPARC_GLOB_JMP (line 911) | pub const R_SPARC_GLOB_JMP: u32 = 42;
constant R_SPARC_7 (line 912) | pub const R_SPARC_7: u32 = 43;
constant R_SPARC_5 (line 913) | pub const R_SPARC_5: u32 = 44;
constant R_SPARC_6 (line 914) | pub const R_SPARC_6: u32 = 45;
constant R_SPARC_DISP64 (line 915) | pub const R_SPARC_DISP64: u32 = 46;
constant R_SPARC_PLT64 (line 916) | pub const R_SPARC_PLT64: u32 = 47;
constant R_SPARC_HIX22 (line 917) | pub const R_SPARC_HIX22: u32 = 48;
constant R_SPARC_LOX10 (line 918) | pub const R_SPARC_LOX10: u32 = 49;
constant R_SPARC_H44 (line 919) | pub const R_SPARC_H44: u32 = 50;
constant R_SPARC_M44 (line 920) | pub const R_SPARC_M44: u32 = 51;
constant R_SPARC_L44 (line 921) | pub const R_SPARC_L44: u32 = 52;
constant R_SPARC_REGISTER (line 922) | pub const R_SPARC_REGISTER: u32 = 53;
constant R_SPARC_UA64 (line 923) | pub const R_SPARC_UA64: u32 = 54;
constant R_SPARC_UA16 (line 924) | pub const R_SPARC_UA16: u32 = 55;
constant R_SPARC_TLS_GD_HI22 (line 925) | pub const R_SPARC_TLS_GD_HI22: u32 = 56;
constant R_SPARC_TLS_GD_LO10 (line 926) | pub const R_SPARC_TLS_GD_LO10: u32 = 57;
constant R_SPARC_TLS_GD_ADD (line 927) | pub const R_SPARC_TLS_GD_ADD: u32 = 58;
constant R_SPARC_TLS_GD_CALL (line 928) | pub const R_SPARC_TLS_GD_CALL: u32 = 59;
constant R_SPARC_TLS_LDM_HI22 (line 929) | pub const R_SPARC_TLS_LDM_HI22: u32 = 60;
constant R_SPARC_TLS_LDM_LO10 (line 930) | pub const R_SPARC_TLS_LDM_LO10: u32 = 61;
constant R_SPARC_TLS_LDM_ADD (line 931) | pub const R_SPARC_TLS_LDM_ADD: u32 = 62;
constant R_SPARC_TLS_LDM_CALL (line 932) | pub const R_SPARC_TLS_LDM_CALL: u32 = 63;
constant R_SPARC_TLS_LDO_HIX22 (line 933) | pub const R_SPARC_TLS_LDO_HIX22: u32 = 64;
constant R_SPARC_TLS_LDO_LOX10 (line 934) | pub const R_SPARC_TLS_LDO_LOX10: u32 = 65;
constant R_SPARC_TLS_LDO_ADD (line 935) | pub const R_SPARC_TLS_LDO_ADD: u32 = 66;
constant R_SPARC_TLS_IE_HI22 (line 936) | pub const R_SPARC_TLS_IE_HI22: u32 = 67;
constant R_SPARC_TLS_IE_LO10 (line 937) | pub const R_SPARC_TLS_IE_LO10: u32 = 68;
constant R_SPARC_TLS_IE_LD (line 938) | pub const R_SPARC_TLS_IE_LD: u32 = 69;
constant R_SPARC_TLS_IE_LDX (line 939) | pub const R_SPARC_TLS_IE_LDX: u32 = 70;
constant R_SPARC_TLS_IE_ADD (line 940) | pub const R_SPARC_TLS_IE_ADD: u32 = 71;
constant R_SPARC_TLS_LE_HIX22 (line 941) | pub const R_SPARC_TLS_LE_HIX22: u32 = 72;
constant R_SPARC_TLS_LE_LOX10 (line 942) | pub const R_SPARC_TLS_LE_LOX10: u32 = 73;
constant R_SPARC_TLS_DTPMOD32 (line 943) | pub const R_SPARC_TLS_DTPMOD32: u32 = 74;
constant R_SPARC_TLS_DTPMOD64 (line 944) | pub const R_SPARC_TLS_DTPMOD64: u32 = 75;
constant R_SPARC_TLS_DTPOFF32 (line 945) | pub const R_SPARC_TLS_DTPOFF32: u32 = 76;
constant R_SPARC_TLS_DTPOFF64 (line 946) | pub const R_SPARC_TLS_DTPOFF64: u32 = 77;
constant R_SPARC_TLS_TPOFF32 (line 947) | pub const R_SPARC_TLS_TPOFF32: u32 = 78;
constant R_SPARC_TLS_TPOFF64 (line 948) | pub const R_SPARC_TLS_TPOFF64: u32 = 79;
constant R_SPARC_GOTDATA_HIX22 (line 949) | pub const R_SPARC_GOTDATA_HIX22: u32 = 80;
constant R_SPARC_GOTDATA_LOX10 (line 950) | pub const R_SPARC_GOTDATA_LOX10: u32 = 81;
constant R_SPARC_GOTDATA_OP_HIX22 (line 951) | pub const R_SPARC_GOTDATA_OP_HIX22: u32 = 82;
constant R_SPARC_GOTDATA_OP_LOX10 (line 952) | pub const R_SPARC_GOTDATA_OP_LOX10: u32 = 83;
constant R_SPARC_GOTDATA_OP (line 953) | pub const R_SPARC_GOTDATA_OP: u32 = 84;
constant R_SPARC_H34 (line 954) | pub const R_SPARC_H34: u32 = 85;
constant R_SPARC_SIZE32 (line 955) | pub const R_SPARC_SIZE32: u32 = 86;
constant R_SPARC_SIZE64 (line 956) | pub const R_SPARC_SIZE64: u32 = 87;
constant R_SPARC_WDISP10 (line 957) | pub const R_SPARC_WDISP10: u32 = 88;
constant R_SPARC_JMP_IREL (line 958) | pub const R_SPARC_JMP_IREL: u32 = 248;
constant R_SPARC_IRELATIVE (line 959) | pub const R_SPARC_IRELATIVE: u32 = 249;
constant R_SPARC_GNU_VTINHERIT (line 960) | pub const R_SPARC_GNU_VTINHERIT: u32 = 250;
constant R_SPARC_GNU_VTENTRY (line 961) | pub const R_SPARC_GNU_VTENTRY: u32 = 251;
constant R_SPARC_REV32 (line 962) | pub const R_SPARC_REV32: u32 = 252;
constant R_SPARC_NUM (line 963) | pub const R_SPARC_NUM: u32 = 253;
constant DT_SPARC_REGISTER (line 964) | pub const DT_SPARC_REGISTER: u32 = 1879048193;
constant DT_SPARC_NUM (line 965) | pub const DT_SPARC_NUM: u32 = 2;
constant EF_MIPS_NOREORDER (line 966) | pub const EF_MIPS_NOREORDER: u32 = 1;
constant EF_MIPS_PIC (line 967) | pub const EF_MIPS_PIC: u32 = 2;
constant EF_MIPS_CPIC (line 968) | pub const EF_MIPS_CPIC: u32 = 4;
constant EF_MIPS_XGOT (line 969) | pub const EF_MIPS_XGOT: u32 = 8;
constant EF_MIPS_64BIT_WHIRL (line 970) | pub const EF_MIPS_64BIT_WHIRL: u32 = 16;
constant EF_MIPS_ABI2 (line 971) | pub const EF_MIPS_ABI2: u32 = 32;
constant EF_MIPS_ABI_ON32 (line 972) | pub const EF_MIPS_ABI_ON32: u32 = 64;
constant EF_MIPS_FP64 (line 973) | pub const EF_MIPS_FP64: u32 = 512;
constant EF_MIPS_NAN2008 (line 974) | pub const EF_MIPS_NAN2008: u32 = 1024;
constant EF_MIPS_ARCH (line 975) | pub const EF_MIPS_ARCH: u32 = 4026531840;
constant EF_MIPS_ARCH_1 (line 976) | pub const EF_MIPS_ARCH_1: u32 = 0;
constant EF_MIPS_ARCH_2 (line 977) | pub const EF_MIPS_ARCH_2: u32 = 268435456;
constant EF_MIPS_ARCH_3 (line 978) | pub const EF_MIPS_ARCH_3: u32 = 536870912;
constant EF_MIPS_ARCH_4 (line 979) | pub const EF_MIPS_ARCH_4: u32 = 805306368;
constant EF_MIPS_ARCH_5 (line 980) | pub const EF_MIPS_ARCH_5: u32 = 1073741824;
constant EF_MIPS_ARCH_32 (line 981) | pub const EF_MIPS_ARCH_32: u32 = 1342177280;
constant EF_MIPS_ARCH_64 (line 982) | pub const EF_MIPS_ARCH_64: u32 = 1610612736;
constant EF_MIPS_ARCH_32R2 (line 983) | pub const EF_MIPS_ARCH_32R2: u32 = 1879048192;
constant EF_MIPS_ARCH_64R2 (line 984) | pub const EF_MIPS_ARCH_64R2: u32 = 2147483648;
constant E_MIPS_ARCH_1 (line 985) | pub const E_MIPS_ARCH_1: u32 = 0;
constant E_MIPS_ARCH_2 (line 986) | pub const E_MIPS_ARCH_2: u32 = 268435456;
constant E_MIPS_ARCH_3 (line 987) | pub const E_MIPS_ARCH_3: u32 = 536870912;
constant E_MIPS_ARCH_4 (line 988) | pub const E_MIPS_ARCH_4: u32 = 805306368;
constant E_MIPS_ARCH_5 (line 989) | pub const E_MIPS_ARCH_5: u32 = 1073741824;
constant E_MIPS_ARCH_32 (line 990) | pub const E_MIPS_ARCH_32: u32 = 1342177280;
constant E_MIPS_ARCH_64 (line 991) | pub const E_MIPS_ARCH_64: u32 = 1610612736;
constant SHN_MIPS_ACOMMON (line 992) | pub const SHN_MIPS_ACOMMON: u32 = 65280;
constant SHN_MIPS_TEXT (line 993) | pub const SHN_MIPS_TEXT: u32 = 65281;
constant SHN_MIPS_DATA (line 994) | pub const SHN_MIPS_DATA: u32 = 65282;
constant SHN_MIPS_SCOMMON (line 995) | pub const SHN_MIPS_SCOMMON: u32 = 65283;
constant SHN_MIPS_SUNDEFINED (line 996) | pub const SHN_MIPS_SUNDEFINED: u32 = 65284;
constant SHT_MIPS_LIBLIST (line 997) | pub const SHT_MIPS_LIBLIST: u32 = 1879048192;
constant SHT_MIPS_MSYM (line 998) | pub const SHT_MIPS_MSYM: u32 = 1879048193;
constant SHT_MIPS_CONFLICT (line 999) | pub const SHT_MIPS_CONFLICT: u32 = 1879048194;
constant SHT_MIPS_GPTAB (line 1000) | pub const SHT_MIPS_GPTAB: u32 = 1879048195;
constant SHT_MIPS_UCODE (line 1001) | pub const SHT_MIPS_UCODE: u32 = 1879048196;
constant SHT_MIPS_DEBUG (line 1002) | pub const SHT_MIPS_DEBUG: u32 = 1879048197;
constant SHT_MIPS_REGINFO (line 1003) | pub const SHT_MIPS_REGINFO: u32 = 1879048198;
constant SHT_MIPS_PACKAGE (line 1004) | pub const SHT_MIPS_PACKAGE: u32 = 1879048199;
constant SHT_MIPS_PACKSYM (line 1005) | pub const SHT_MIPS_PACKSYM: u32 = 1879048200;
constant SHT_MIPS_RELD (line 1006) | pub const SHT_MIPS_RELD: u32 = 1879048201;
constant SHT_MIPS_IFACE (line 1007) | pub const SHT_MIPS_IFACE: u32 = 1879048203;
constant SHT_MIPS_CONTENT (line 1008) | pub const SHT_MIPS_CONTENT: u32 = 1879048204;
constant SHT_MIPS_OPTIONS (line 1009) | pub const SHT_MIPS_OPTIONS: u32 = 1879048205;
constant SHT_MIPS_SHDR (line 1010) | pub const SHT_MIPS_SHDR: u32 = 1879048208;
constant SHT_MIPS_FDESC (line 1011) | pub const SHT_MIPS_FDESC: u32 = 1879048209;
constant SHT_MIPS_EXTSYM (line 1012) | pub const SHT_MIPS_EXTSYM: u32 = 1879048210;
constant SHT_MIPS_DENSE (line 1013) | pub const SHT_MIPS_DENSE: u32 = 1879048211;
constant SHT_MIPS_PDESC (line 1014) | pub const SHT_MIPS_PDESC: u32 = 1879048212;
constant SHT_MIPS_LOCSYM (line 1015) | pub const SHT_MIPS_LOCSYM: u32 = 1879048213;
constant SHT_MIPS_AUXSYM (line 1016) | pub const SHT_MIPS_AUXSYM: u32 = 1879048214;
constant SHT_MIPS_OPTSYM (line 1017) | pub const SHT_MIPS_OPTSYM: u32 = 1879048215;
constant SHT_MIPS_LOCSTR (line 1018) | pub const SHT_MIPS_LOCSTR: u32 = 1879048216;
constant SHT_MIPS_LINE (line 1019) | pub const SHT_MIPS_LINE: u32 = 1879048217;
constant SHT_MIPS_RFDESC (line 1020) | pub const SHT_MIPS_RFDESC: u32 = 1879048218;
constant SHT_MIPS_DELTASYM (line 1021) | pub const SHT_MIPS_DELTASYM: u32 = 1879048219;
constant SHT_MIPS_DELTAINST (line 1022) | pub const SHT_MIPS_DELTAINST: u32 = 1879048220;
constant SHT_MIPS_DELTACLASS (line 1023) | pub const SHT_MIPS_DELTACLASS: u32 = 1879048221;
constant SHT_MIPS_DWARF (line 1024) | pub const SHT_MIPS_DWARF: u32 = 1879048222;
constant SHT_MIPS_DELTADECL (line 1025) | pub const SHT_MIPS_DELTADECL: u32 = 1879048223;
constant SHT_MIPS_SYMBOL_LIB (line 1026) | pub const SHT_MIPS_SYMBOL_LIB: u32 = 1879048224;
constant SHT_MIPS_EVENTS (line 1027) | pub const SHT_MIPS_EVENTS: u32 = 1879048225;
constant SHT_MIPS_TRANSLATE (line 1028) | pub const SHT_MIPS_TRANSLATE: u32 = 1879048226;
constant SHT_MIPS_PIXIE (line 1029) | pub const SHT_MIPS_PIXIE: u32 = 1879048227;
constant SHT_MIPS_XLATE (line 1030) | pub const SHT_MIPS_XLATE: u32 = 1879048228;
constant SHT_MIPS_XLATE_DEBUG (line 1031) | pub const SHT_MIPS_XLATE_DEBUG: u32 = 1879048229;
constant SHT_MIPS_WHIRL (line 1032) | pub const SHT_MIPS_WHIRL: u32 = 1879048230;
constant SHT_MIPS_EH_REGION (line 1033) | pub const SHT_MIPS_EH_REGION: u32 = 1879048231;
constant SHT_MIPS_XLATE_OLD (line 1034) | pub const SHT_MIPS_XLATE_OLD: u32 = 1879048232;
constant SHT_MIPS_PDR_EXCEPTION (line 1035) | pub const SHT_MIPS_PDR_EXCEPTION: u32 = 1879048233;
constant SHF_MIPS_GPREL (line 1036) | pub const SHF_MIPS_GPREL: u32 = 268435456;
constant SHF_MIPS_MERGE (line 1037) | pub const SHF_MIPS_MERGE: u32 = 536870912;
constant SHF_MIPS_ADDR (line 1038) | pub const SHF_MIPS_ADDR: u32 = 1073741824;
constant SHF_MIPS_STRINGS (line 1039) | pub const SHF_MIPS_STRINGS: u32 = 2147483648;
constant SHF_MIPS_NOSTRIP (line 1040) | pub const SHF_MIPS_NOSTRIP: u32 = 134217728;
constant SHF_MIPS_LOCAL (line 1041) | pub const SHF_MIPS_LOCAL: u32 = 67108864;
constant SHF_MIPS_NAMES (line 1042) | pub const SHF_MIPS_NAMES: u32 = 33554432;
constant SHF_MIPS_NODUPE (line 1043) | pub const SHF_MIPS_NODUPE: u32 = 16777216;
constant STO_MIPS_DEFAULT (line 1044) | pub const STO_MIPS_DEFAULT: u32 = 0;
constant STO_MIPS_INTERNAL (line 1045) | pub const STO_MIPS_INTERNAL: u32 = 1;
constant STO_MIPS_HIDDEN (line 1046) | pub const STO_MIPS_HIDDEN: u32 = 2;
constant STO_MIPS_PROTECTED (line 1047) | pub const STO_MIPS_PROTECTED: u32 = 3;
constant STO_MIPS_PLT (line 1048) | pub const STO_MIPS_PLT: u32 = 8;
constant STO_MIPS_SC_ALIGN_UNUSED (line 1049) | pub const STO_MIPS_SC_ALIGN_UNUSED: u32 = 255;
constant STB_MIPS_SPLIT_COMMON (line 1050) | pub const STB_MIPS_SPLIT_COMMON: u32 = 13;
constant ODK_NULL (line 1051) | pub const ODK_NULL: u32 = 0;
constant ODK_REGINFO (line 1052) | pub const ODK_REGINFO: u32 = 1;
constant ODK_EXCEPTIONS (line 1053) | pub const ODK_EXCEPTIONS: u32 = 2;
constant ODK_PAD (line 1054) | pub const ODK_PAD: u32 = 3;
constant ODK_HWPATCH (line 1055) | pub const ODK_HWPATCH: u32 = 4;
constant ODK_FILL (line 1056) | pub const ODK_FILL: u32 = 5;
constant ODK_TAGS (line 1057) | pub const ODK_TAGS: u32 = 6;
constant ODK_HWAND (line 1058) | pub const ODK_HWAND: u32 = 7;
constant ODK_HWOR (line 1059) | pub const ODK_HWOR: u32 = 8;
constant OEX_FPU_MIN (line 1060) | pub const OEX_FPU_MIN: u32 = 31;
constant OEX_FPU_MAX (line 1061) | pub const OEX_FPU_MAX: u32 = 7936;
constant OEX_PAGE0 (line 1062) | pub const OEX_PAGE0: u32 = 65536;
constant OEX_SMM (line 1063) | pub const OEX_SMM: u32 = 131072;
constant OEX_FPDBUG (line 1064) | pub const OEX_FPDBUG: u32 = 262144;
constant OEX_PRECISEFP (line 1065) | pub const OEX_PRECISEFP: u32 = 262144;
constant OEX_DISMISS (line 1066) | pub const OEX_DISMISS: u32 = 524288;
constant OEX_FPU_INVAL (line 1067) | pub const OEX_FPU_INVAL: u32 = 16;
constant OEX_FPU_DIV0 (line 1068) | pub const OEX_FPU_DIV0: u32 = 8;
constant OEX_FPU_OFLO (line 1069) | pub const OEX_FPU_OFLO: u32 = 4;
constant OEX_FPU_UFLO (line 1070) | pub const OEX_FPU_UFLO: u32 = 2;
constant OEX_FPU_INEX (line 1071) | pub const OEX_FPU_INEX: u32 = 1;
constant OHW_R4KEOP (line 1072) | pub const OHW_R4KEOP: u32 = 1;
constant OHW_R8KPFETCH (line 1073) | pub const OHW_R8KPFETCH: u32 = 2;
constant OHW_R5KEOP (line 1074) | pub const OHW_R5KEOP: u32 = 4;
constant OHW_R5KCVTL (line 1075) | pub const OHW_R5KCVTL: u32 = 8;
constant OPAD_PREFIX (line 1076) | pub const OPAD_PREFIX: u32 = 1;
constant OPAD_POSTFIX (line 1077) | pub const OPAD_POSTFIX: u32 = 2;
constant OPAD_SYMBOL (line 1078) | pub const OPAD_SYMBOL: u32 = 4;
constant OHWA0_R4KEOP_CHECKED (line 1079) | pub const OHWA0_R4KEOP_CHECKED: u32 = 1;
constant OHWA1_R4KEOP_CLEAN (line 1080) | pub const OHWA1_R4KEOP_CLEAN: u32 = 2;
constant R_MIPS_NONE (line 1081) | pub const R_MIPS_NONE: u32 = 0;
constant R_MIPS_16 (line 1082) | pub const R_MIPS_16: u32 = 1;
constant R_MIPS_32 (line 1083) | pub const R_MIPS_32: u32 = 2;
constant R_MIPS_REL32 (line 1084) | pub const R_MIPS_REL32: u32 = 3;
constant R_MIPS_26 (line 1085) | pub const R_MIPS_26: u32 = 4;
constant R_MIPS_HI16 (line 1086) | pub const R_MIPS_HI16: u32 = 5;
constant R_MIPS_LO16 (line 1087) | pub const R_MIPS_LO16: u32 = 6;
constant R_MIPS_GPREL16 (line 1088) | pub const R_MIPS_GPREL16: u32 = 7;
constant R_MIPS_LITERAL (line 1089) | pub const R_MIPS_LITERAL: u32 = 8;
constant R_MIPS_GOT16 (line 1090) | pub const R_MIPS_GOT16: u32 = 9;
constant R_MIPS_PC16 (line 1091) | pub const R_MIPS_PC16: u32 = 10;
constant R_MIPS_CALL16 (line 1092) | pub const R_MIPS_CALL16: u32 = 11;
constant R_MIPS_GPREL32 (line 1093) | pub const R_MIPS_GPREL32: u32 = 12;
constant R_MIPS_SHIFT5 (line 1094) | pub const R_MIPS_SHIFT5: u32 = 16;
constant R_MIPS_SHIFT6 (line 1095) | pub const R_MIPS_SHIFT6: u32 = 17;
constant R_MIPS_64 (line 1096) | pub const R_MIPS_64: u32 = 18;
constant R_MIPS_GOT_DISP (line 1097) | pub const R_MIPS_GOT_DISP: u32 = 19;
constant R_MIPS_GOT_PAGE (line 1098) | pub const R_MIPS_GOT_PAGE: u32 = 20;
constant R_MIPS_GOT_OFST (line 1099) | pub const R_MIPS_GOT_OFST: u32 = 21;
constant R_MIPS_GOT_HI16 (line 1100) | pub const R_MIPS_GOT_HI16: u32 = 22;
constant R_MIPS_GOT_LO16 (line 1101) | pub const R_MIPS_GOT_LO16: u32 = 23;
constant R_MIPS_SUB (line 1102) | pub const R_MIPS_SUB: u32 = 24;
constant R_MIPS_INSERT_A (line 1103) | pub const R_MIPS_INSERT_A: u32 = 25;
constant R_MIPS_INSERT_B (line 1104) | pub const R_MIPS_INSERT_B: u32 = 26;
constant R_MIPS_DELETE (line 1105) | pub const R_MIPS_DELETE: u32 = 27;
constant R_MIPS_HIGHER (line 1106) | pub const R_MIPS_HIGHER: u32 = 28;
constant R_MIPS_HIGHEST (line 1107) | pub const R_MIPS_HIGHEST: u32 = 29;
constant R_MIPS_CALL_HI16 (line 1108) | pub const R_MIPS_CALL_HI16: u32 = 30;
constant R_MIPS_CALL_LO16 (line 1109) | pub const R_MIPS_CALL_LO16: u32 = 31;
constant R_MIPS_SCN_DISP (line 1110) | pub const R_MIPS_SCN_DISP: u32 = 32;
constant R_MIPS_REL16 (line 1111) | pub const R_MIPS_REL16: u32 = 33;
constant R_MIPS_ADD_IMMEDIATE (line 1112) | pub const R_MIPS_ADD_IMMEDIATE: u32 = 34;
constant R_MIPS_PJUMP (line 1113) | pub const R_MIPS_PJUMP: u32 = 35;
constant R_MIPS_RELGOT (line 1114) | pub const R_MIPS_RELGOT: u32 = 36;
constant R_MIPS_JALR (line 1115) | pub const R_MIPS_JALR: u32 = 37;
constant R_MIPS_TLS_DTPMOD32 (line 1116) | pub const R_MIPS_TLS_DTPMOD32: u32 = 38;
constant R_MIPS_TLS_DTPREL32 (line 1117) | pub const R_MIPS_TLS_DTPREL32: u32 = 39;
constant R_MIPS_TLS_DTPMOD64 (line 1118) | pub const R_MIPS_TLS_DTPMOD64: u32 = 40;
constant R_MIPS_TLS_DTPREL64 (line 1119) | pub const R_MIPS_TLS_DTPREL64: u32 = 41;
constant R_MIPS_TLS_GD (line 1120) | pub const R_MIPS_TLS_GD: u32 = 42;
constant R_MIPS_TLS_LDM (line 1121) | pub const R_MIPS_TLS_LDM: u32 = 43;
constant R_MIPS_TLS_DTPREL_HI16 (line 1122) | pub const R_MIPS_TLS_DTPREL_HI16: u32 = 44;
constant R_MIPS_TLS_DTPREL_LO16 (line 1123) | pub const R_MIPS_TLS_DTPREL_LO16: u32 = 45;
constant R_MIPS_TLS_GOTTPREL (line 1124) | pub const R_MIPS_TLS_GOTTPREL: u32 = 46;
constant R_MIPS_TLS_TPREL32 (line 1125) | pub const R_MIPS_TLS_TPREL32: u32 = 47;
constant R_MIPS_TLS_TPREL64 (line 1126) | pub const R_MIPS_TLS_TPREL64: u32 = 48;
constant R_MIPS_TLS_TPREL_HI16 (line 1127) | pub const R_MIPS_TLS_TPREL_HI16: u32 = 49;
constant R_MIPS_TLS_TPREL_LO16 (line 1128) | pub const R_MIPS_TLS_TPREL_LO16: u32 = 50;
constant R_MIPS_GLOB_DAT (line 1129) | pub const R_MIPS_GLOB_DAT: u32 = 51;
constant R_MIPS_COPY (line 1130) | pub const R_MIPS_COPY: u32 = 126;
constant R_MIPS_JUMP_SLOT (line 1131) | pub const R_MIPS_JUMP_SLOT: u32 = 127;
constant R_MIPS_NUM (line 1132) | pub const R_MIPS_NUM: u32 = 128;
constant PT_MIPS_REGINFO (line 1133) | pub const PT_MIPS_REGINFO: u32 = 1879048192;
constant PT_MIPS_RTPROC (line 1134) | pub const PT_MIPS_RTPROC: u32 = 1879048193;
constant PT_MIPS_OPTIONS (line 1135) | pub const PT_MIPS_OPTIONS: u32 = 1879048194;
constant PT_MIPS_ABIFLAGS (line 1136) | pub const PT_MIPS_ABIFLAGS: u32 = 1879048195;
constant PF_MIPS_LOCAL (line 1137) | pub const PF_MIPS_LOCAL: u32 = 268435456;
constant DT_MIPS_RLD_VERSION (line 1138) | pub const DT_MIPS_RLD_VERSION: u32 = 1879048193;
constant DT_MIPS_TIME_STAMP (line 1139) | pub const DT_MIPS_TIME_STAMP: u32 = 1879048194;
constant DT_MIPS_ICHECKSUM (line 1140) | pub const DT_MIPS_ICHECKSUM: u32 = 1879048195;
constant DT_MIPS_IVERSION (line 1141) | pub const DT_MIPS_IVERSION: u32 = 1879048196;
constant DT_MIPS_FLAGS (line 1142) | pub const DT_MIPS_FLAGS: u32 = 1879048197;
constant DT_MIPS_BASE_ADDRESS (line 1143) | pub const DT_MIPS_BASE_ADDRESS: u32 = 1879048198;
constant DT_MIPS_MSYM (line 1144) | pub const DT_MIPS_MSYM: u32 = 1879048199;
constant DT_MIPS_CONFLICT (line 1145) | pub const DT_MIPS_CONFLICT: u32 = 1879048200;
constant DT_MIPS_LIBLIST (line 1146) | pub const DT_MIPS_LIBLIST: u32 = 1879048201;
constant DT_MIPS_LOCAL_GOTNO (line 1147) | pub const DT_MIPS_LOCAL_GOTNO: u32 = 1879048202;
constant DT_MIPS_CONFLICTNO (line 1148) | pub const DT_MIPS_CONFLICTNO: u32 = 1879048203;
constant DT_MIPS_LIBLISTNO (line 1149) | pub const DT_MIPS_LIBLISTNO: u32 = 1879048208;
constant DT_MIPS_SYMTABNO (line 1150) | pub const DT_MIPS_SYMTABNO: u32 = 1879048209;
constant DT_MIPS_UNREFEXTNO (line 1151) | pub const DT_MIPS_UNREFEXTNO: u32 = 1879048210;
constant DT_MIPS_GOTSYM (line 1152) | pub const DT_MIPS_GOTSYM: u32 = 1879048211;
constant DT_MIPS_HIPAGENO (line 1153) | pub const DT_MIPS_HIPAGENO: u32 = 1879048212;
constant DT_MIPS_RLD_MAP (line 1154) | pub const DT_MIPS_RLD_MAP: u32 = 1879048214;
constant DT_MIPS_DELTA_CLASS (line 1155) | pub const DT_MIPS_DELTA_CLASS: u32 = 1879048215;
constant DT_MIPS_DELTA_CLASS_NO (line 1156) | pub const DT_MIPS_DELTA_CLASS_NO: u32 = 1879048216;
constant DT_MIPS_DELTA_INSTANCE (line 1157) | pub const DT_MIPS_DELTA_INSTANCE: u32 = 1879048217;
constant DT_MIPS_DELTA_INSTANCE_NO (line 1158) | pub const DT_MIPS_DELTA_INSTANCE_NO: u32 = 1879048218;
constant DT_MIPS_DELTA_RELOC (line 1159) | pub const DT_MIPS_DELTA_RELOC: u32 = 1879048219;
constant DT_MIPS_DELTA_RELOC_NO (line 1160) | pub const DT_MIPS_DELTA_RELOC_NO: u32 = 1879048220;
constant DT_MIPS_DELTA_SYM (line 1161) | pub const DT_MIPS_DELTA_SYM: u32 = 1879048221;
constant DT_MIPS_DELTA_SYM_NO (line 1162) | pub const DT_MIPS_DELTA_SYM_NO: u32 = 1879048222;
constant DT_MIPS_DELTA_CLASSSYM (line 1163) | pub const DT_MIPS_DELTA_CLASSSYM: u32 = 1879048224;
constant DT_MIPS_DELTA_CLASSSYM_NO (line 1164) | pub const DT_MIPS_DELTA_CLASSSYM_NO: u32 = 1879048225;
constant DT_MIPS_CXX_FLAGS (line 1165) | pub const DT_MIPS_CXX_FLAGS: u32 = 1879048226;
constant DT_MIPS_PIXIE_INIT (line 1166) | pub const DT_MIPS_PIXIE_INIT: u32 = 1879048227;
constant DT_MIPS_SYMBOL_LIB (line 1167) | pub const DT_MIPS_SYMBOL_LIB: u32 = 1879048228;
constant DT_MIPS_LOCALPAGE_GOTIDX (line 1168) | pub const DT_MIPS_LOCALPAGE_GOTIDX: u32 = 1879048229;
constant DT_MIPS_LOCAL_GOTIDX (line 1169) | pub const DT_MIPS_LOCAL_GOTIDX: u32 = 1879048230;
constant DT_MIPS_HIDDEN_GOTIDX (line 1170) | pub const DT_MIPS_HIDDEN_GOTIDX: u32 = 1879048231;
constant DT_MIPS_PROTECTED_GOTIDX (line 1171) | pub const DT_MIPS_PROTECTED_GOTIDX: u32 = 1879048232;
constant DT_MIPS_OPTIONS (line 1172) | pub const DT_MIPS_OPTIONS: u32 = 1879048233;
constant DT_MIPS_INTERFACE (line 1173) | pub const DT_MIPS_INTERFACE: u32 = 1879048234;
constant DT_MIPS_DYNSTR_ALIGN (line 1174) | pub const DT_MIPS_DYNSTR_ALIGN: u32 = 1879048235;
constant DT_MIPS_INTERFACE_SIZE (line 1175) | pub const DT_MIPS_INTERFACE_SIZE: u32 = 1879048236;
constant DT_MIPS_RLD_TEXT_RESOLVE_ADDR (line 1176) | pub const DT_MIPS_RLD_TEXT_RESOLVE_ADDR: u32 = 1879048237;
constant DT_MIPS_PERF_SUFFIX (line 1177) | pub const DT_MIPS_PERF_SUFFIX: u32 = 1879048238;
constant DT_MIPS_COMPACT_SIZE (line 1178) | pub const DT_MIPS_COMPACT_SIZE: u32 = 1879048239;
constant DT_MIPS_GP_VALUE (line 1179) | pub const DT_MIPS_GP_VALUE: u32 = 1879048240;
constant DT_MIPS_AUX_DYNAMIC (line 1180) | pub const DT_MIPS_AUX_DYNAMIC: u32 = 1879048241;
constant DT_MIPS_PLTGOT (line 1181) | pub const DT_MIPS_PLTGOT: u32 = 1879048242;
constant DT_MIPS_RWPLT (line 1182) | pub const DT_MIPS_RWPLT: u32 = 1879048244;
constant DT_MIPS_RLD_MAP_REL (line 1183) | pub const DT_MIPS_RLD_MAP_REL: u32 = 1879048245;
constant DT_MIPS_NUM (line 1184) | pub const DT_MIPS_NUM: u32 = 54;
constant RHF_NONE (line 1185) | pub const RHF_NONE: u32 = 0;
constant RHF_QUICKSTART (line 1186) | pub const RHF_QUICKSTART: u32 = 1;
constant RHF_NOTPOT (line 1187) | pub const RHF_NOTPOT: u32 = 2;
constant RHF_NO_LIBRARY_REPLACEMENT (line 1188) | pub const RHF_NO_LIBRARY_REPLACEMENT: u32 = 4;
constant RHF_NO_MOVE (line 1189) | pub const RHF_NO_MOVE: u32 = 8;
constant RHF_SGI_ONLY (line 1190) | pub const RHF_SGI_ONLY: u32 = 16;
constant RHF_GUARANTEE_INIT (line 1191) | pub const RHF_GUARANTEE_INIT: u32 = 32;
constant RHF_DELTA_C_PLUS_PLUS (line 1192) | pub const RHF_DELTA_C_PLUS_PLUS: u32 = 64;
constant RHF_GUARANTEE_START_INIT (line 1193) | pub const RHF_GUARANTEE_START_INIT: u32 = 128;
constant RHF_PIXIE (line 1194) | pub const RHF_PIXIE: u32 = 256;
constant RHF_DEFAULT_DELAY_LOAD (line 1195) | pub const RHF_DEFAULT_DELAY_LOAD: u32 = 512;
constant RHF_REQUICKSTART (line 1196) | pub const RHF_REQUICKSTART: u32 = 1024;
constant RHF_REQUICKSTARTED (line 1197) | pub const RHF_REQUICKSTARTED: u32 = 2048;
constant RHF_CORD (line 1198) | pub const RHF_CORD: u32 = 4096;
constant RHF_NO_UNRES_UNDEF (line 1199) | pub const RHF_NO_UNRES_UNDEF: u32 = 8192;
constant RHF_RLD_ORDER_SAFE (line 1200) | pub const RHF_RLD_ORDER_SAFE: u32 = 16384;
constant LL_NONE (line 1201) | pub const LL_NONE: u32 = 0;
constant LL_EXACT_MATCH (line 1202) | pub const LL_EXACT_MATCH: u32 = 1;
constant LL_IGNORE_INT_VER (line 1203) | pub const LL_IGNORE_INT_VER: u32 = 2;
constant LL_REQUIRE_MINOR (line 1204) | pub const LL_REQUIRE_MINOR: u32 = 4;
constant LL_EXPORTS (line 1205) | pub const LL_EXPORTS: u32 = 8;
constant LL_DELAY_LOAD (line 1206) | pub const LL_DELAY_LOAD: u32 = 16;
constant LL_DELTA (line 1207) | pub const LL_DELTA: u32 = 32;
constant MIPS_AFL_REG_NONE (line 1208) | pub const MIPS_AFL_REG_NONE: u32 = 0;
constant MIPS_AFL_REG_32 (line 1209) | pub const MIPS_AFL_REG_32: u32 = 1;
constant MIPS_AFL_REG_64 (line 1210) | pub const MIPS_AFL_REG_64: u32 = 2;
constant MIPS_AFL_REG_128 (line 1211) | pub const MIPS_AFL_REG_128: u32 = 3;
constant MIPS_AFL_ASE_DSP (line 1212) | pub const MIPS_AFL_ASE_DSP: u32 = 1;
constant MIPS_AFL_ASE_DSPR2 (line 1213) | pub const MIPS_AFL_ASE_DSPR2: u32 = 2;
constant MIPS_AFL_ASE_EVA (line 1214) | pub const MIPS_AFL_ASE_EVA: u32 = 4;
constant MIPS_AFL_ASE_MCU (line 1215) | pub const MIPS_AFL_ASE_MCU: u32 = 8;
constant MIPS_AFL_ASE_MDMX (line 1216) | pub const MIPS_AFL_ASE_MDMX: u32 = 16;
constant MIPS_AFL_ASE_MIPS3D (line 1217) | pub const MIPS_AFL_ASE_MIPS3D: u32 = 32;
constant MIPS_AFL_ASE_MT (line 1218) | pub const MIPS_AFL_ASE_MT: u32 = 64;
constant MIPS_AFL_ASE_SMARTMIPS (line 1219) | pub const MIPS_AFL_ASE_SMARTMIPS: u32 = 128;
constant MIPS_AFL_ASE_VIRT (line 1220) | pub const MIPS_AFL_ASE_VIRT: u32 = 256;
constant MIPS_AFL_ASE_MSA (line 1221) | pub const MIPS_AFL_ASE_MSA: u32 = 512;
constant MIPS_AFL_ASE_MIPS16 (line 1222) | pub const MIPS_AFL_ASE_MIPS16: u32 = 1024;
constant MIPS_AFL_ASE_MICROMIPS (line 1223) | pub const MIPS_AFL_ASE_MICROMIPS: u32 = 2048;
constant MIPS_AFL_ASE_XPA (line 1224) | pub const MIPS_AFL_ASE_XPA: u32 = 4096;
constant MIPS_AFL_ASE_MASK (line 1225) | pub const MIPS_AFL_ASE_MASK: u32 = 8191;
constant MIPS_AFL_EXT_XLR (line 1226) | pub const MIPS_AFL_EXT_XLR: u32 = 1;
constant MIPS_AFL_EXT_OCTEON2 (line 1227) | pub const MIPS_AFL_EXT_OCTEON2: u32 = 2;
constant MIPS_AFL_EXT_OCTEONP (line 1228) | pub const MIPS_AFL_EXT_OCTEONP: u32 = 3;
constant MIPS_AFL_EXT_LOONGSON_3A (line 1229) | pub const MIPS_AFL_EXT_LOONGSON_3A: u32 = 4;
constant MIPS_AFL_EXT_OCTEON (line 1230) | pub const MIPS_AFL_EXT_OCTEON: u32 = 5;
constant MIPS_AFL_EXT_5900 (line 1231) | pub const MIPS_AFL_EXT_5900: u32 = 6;
constant MIPS_AFL_EXT_4650 (line 1232) | pub const MIPS_AFL_EXT_4650: u32 = 7;
constant MIPS_AFL_EXT_4010 (line 1233) | pub const MIPS_AFL_EXT_4010: u32 = 8;
constant MIPS_AFL_EXT_4100 (line 1234) | pub const MIPS_AFL_EXT_4100: u32 = 9;
constant MIPS_AFL_EXT_3900 (line 1235) | pub const MIPS_AFL_EXT_3900: u32 = 10;
constant MIPS_AFL_EXT_10000 (line 1236) | pub const MIPS_AFL_EXT_10000: u32 = 11;
constant MIPS_AFL_EXT_SB1 (line 1237) | pub const MIPS_AFL_EXT_SB1: u32 = 12;
constant MIPS_AFL_EXT_4111 (line 1238) | pub const MIPS_AFL_EXT_4111: u32 = 13;
constant MIPS_AFL_EXT_4120 (line 1239) | pub const MIPS_AFL_EXT_4120: u32 = 14;
constant MIPS_AFL_EXT_5400 (line 1240) | pub const MIPS_AFL_EXT_5400: u32 = 15;
constant MIPS_AFL_EXT_5500 (line 1241) | pub const MIPS_AFL_EXT_5500: u32 = 16;
constant MIPS_AFL_EXT_LOONGSON_2E (line 1242) | pub const MIPS_AFL_EXT_LOONGSON_2E: u32 = 17;
constant MIPS_AFL_EXT_LOONGSON_2F (line 1243) | pub const MIPS_AFL_EXT_LOONGSON_2F: u32 = 18;
constant MIPS_AFL_FLAGS1_ODDSPREG (line 1244) | pub const MIPS_AFL_FLAGS1_ODDSPREG: u32 = 1;
constant EF_PARISC_TRAPNIL (line 1245) | pub const EF_PARISC_TRAPNIL: u32 = 65536;
constant EF_PARISC_EXT (line 1246) | pub const EF_PARISC_EXT: u32 = 131072;
constant EF_PARISC_LSB (line 1247) | pub const EF_PARISC_LSB: u32 = 262144;
constant EF_PARISC_WIDE (line 1248) | pub const EF_PARISC_WIDE: u32 = 524288;
constant EF_PARISC_NO_KABP (line 1249) | pub const EF_PARISC_NO_KABP: u32 = 1048576;
constant EF_PARISC_LAZYSWAP (line 1250) | pub const EF_PARISC_LAZYSWAP: u32 = 4194304;
constant EF_PARISC_ARCH (line 1251) | pub const EF_PARISC_ARCH: u32 = 65535;
constant EFA_PARISC_1_0 (line 1252) | pub const EFA_PARISC_1_0: u32 = 523;
constant EFA_PARISC_1_1 (line 1253) | pub const EFA_PARISC_1_1: u32 = 528;
constant EFA_PARISC_2_0 (line 1254) | pub const EFA_PARISC_2_0: u32 = 532;
constant SHN_PARISC_ANSI_COMMON (line 1255) | pub const SHN_PARISC_ANSI_COMMON: u32 = 65280;
constant SHN_PARISC_HUGE_COMMON (line 1256) | pub const SHN_PARISC_HUGE_COMMON: u32 = 65281;
constant SHT_PARISC_EXT (line 1257) | pub const SHT_PARISC_EXT: u32 = 1879048192;
constant SHT_PARISC_UNWIND (line 1258) | pub const SHT_PARISC_UNWIND: u32 = 1879048193;
constant SHT_PARISC_DOC (line 1259) | pub const SHT_PARISC_DOC: u32 = 1879048194;
constant SHF_PARISC_SHORT (line 1260) | pub const SHF_PARISC_SHORT: u32 = 536870912;
constant SHF_PARISC_HUGE (line 1261) | pub const SHF_PARISC_HUGE: u32 = 1073741824;
constant SHF_PARISC_SBP (line 1262) | pub const SHF_PARISC_SBP: u32 = 2147483648;
constant STT_PARISC_MILLICODE (line 1263) | pub const STT_PARISC_MILLICODE: u32 = 13;
constant STT_HP_OPAQUE (line 1264) | pub const STT_HP_OPAQUE: u32 = 11;
constant STT_HP_STUB (line 1265) | pub const STT_HP_STUB: u32 = 12;
constant R_PARISC_NONE (line 1266) | pub const R_PARISC_NONE: u32 = 0;
constant R_PARISC_DIR32 (line 1267) | pub const R_PARISC_DIR32: u32 = 1;
constant R_PARISC_DIR21L (line 1268) | pub const R_PARISC_DIR21L: u32 = 2;
constant R_PARISC_DIR17R (line 1269) | pub const R_PARISC_DIR17R: u32 = 3;
constant R_PARISC_DIR17F (line 1270) | pub const R_PARISC_DIR17F: u32 = 4;
constant R_PARISC_DIR14R (line 1271) | pub const R_PARISC_DIR14R: u32 = 6;
constant R_PARISC_PCREL32 (line 1272) | pub const R_PARISC_PCREL32: u32 = 9;
constant R_PARISC_PCREL21L (line 1273) | pub const R_PARISC_PCREL21L: u32 = 10;
constant R_PARISC_PCREL17R (line 1274) | pub const R_PARISC_PCREL17R: u32 = 11;
constant R_PARISC_PCREL17F (line 1275) | pub const R_PARISC_PCREL17F: u32 = 12;
constant R_PARISC_PCREL14R (line 1276) | pub const R_PARISC_PCREL14R: u32 = 14;
constant R_PARISC_DPREL21L (line 1277) | pub const R_PARISC_DPREL21L: u32 = 18;
constant R_PARISC_DPREL14R (line 1278) | pub const R_PARISC_DPREL14R: u32 = 22;
constant R_PARISC_GPREL21L (line 1279) | pub const R_PARISC_GPREL21L: u32 = 26;
constant R_PARISC_GPREL14R (line 1280) | pub const R_PARISC_GPREL14R: u32 = 30;
constant R_PARISC_LTOFF21L (line 1281) | pub const R_PARISC_LTOFF21L: u32 = 34;
constant R_PARISC_LTOFF14R (line 1282) | pub const R_PARISC_LTOFF14R: u32 = 38;
constant R_PARISC_SECREL32 (line 1283) | pub const R_PARISC_SECREL32: u32 = 41;
constant R_PARISC_SEGBASE (line 1284) | pub const R_PARISC_SEGBASE: u32 = 48;
constant R_PARISC_SEGREL32 (line 1285) | pub const R_PARISC_SEGREL32: u32 = 49;
constant R_PARISC_PLTOFF21L (line 1286) | pub const R_PARISC_PLTOFF21L: u32 = 50;
constant R_PARISC_PLTOFF14R (line 1287) | pub const R_PARISC_PLTOFF14R: u32 = 54;
constant R_PARISC_LTOFF_FPTR32 (line 1288) | pub const R_PARISC_LTOFF_FPTR32: u32 = 57;
constant R_PARISC_LTOFF_FPTR21L (line 1289) | pub const R_PARISC_LTOFF_FPTR21L: u32 = 58;
constant R_PARISC_LTOFF_FPTR14R (line 1290) | pub const R_PARISC_LTOFF_FPTR14R: u32 = 62;
constant R_PARISC_FPTR64 (line 1291) | pub const R_PARISC_FPTR64: u32 = 64;
constant R_PARISC_PLABEL32 (line 1292) | pub const R_PARISC_PLABEL32: u32 = 65;
constant R_PARISC_PLABEL21L (line 1293) | pub const R_PARISC_PLABEL21L: u32 = 66;
constant R_PARISC_PLABEL14R (line 1294) | pub const R_PARISC_PLABEL14R: u32 = 70;
constant R_PARISC_PCREL64 (line 1295) | pub const R_PARISC_PCREL64: u32 = 72;
constant R_PARISC_PCREL22F (line 1296) | pub const R_PARISC_PCREL22F: u32 = 74;
constant R_PARISC_PCREL14WR (line 1297) | pub const R_PARISC_PCREL14WR: u32 = 75;
constant R_PARISC_PCREL14DR (line 1298) | pub const R_PARISC_PCREL14DR: u32 = 76;
constant R_PARISC_PCREL16F (line 1299) | pub const R_PARISC_PCREL16F: u32 = 77;
constant R_PARISC_PCREL16WF (line 1300) | pub const R_PARISC_PCREL16WF: u32 = 78;
constant R_PARISC_PCREL16DF (line 1301) | pub const R_PARISC_PCREL16DF: u32 = 79;
constant R_PARISC_DIR64 (line 1302) | pub const R_PARISC_DIR64: u32 = 80;
constant R_PARISC_DIR14WR (line 1303) | pub const R_PARISC_DIR14WR: u32 = 83;
constant R_PARISC_DIR14DR (line 1304) | pub const R_PARISC_DIR14DR: u32 = 84;
constant R_PARISC_DIR16F (line 1305) | pub const R_PARISC_DIR16F: u32 = 85;
constant R_PARISC_DIR16WF (line 1306) | pub const R_PARISC_DIR16WF: u32 = 86;
constant R_PARISC_DIR16DF (line 1307) | pub const R_PARISC_DIR16DF: u32 = 87;
constant R_PARISC_GPREL64 (line 1308) | pub const R_PARISC_GPREL64: u32 = 88;
constant R_PARISC_GPREL14WR (line 1309) | pub const R_PARISC_GPREL14WR: u32 = 91;
constant R_PARISC_GPREL14DR (line 1310) | pub const R_PARISC_GPREL14DR: u32 = 92;
constant R_PARISC_GPREL16F (line 1311) | pub const R_PARISC_GPREL16F: u32 = 93;
constant R_PARISC_GPREL16WF (line 1312) | pub const R_PARISC_GPREL16WF: u32 = 94;
constant R_PARISC_GPREL16DF (line 1313) | pub const R_PARISC_GPREL16DF: u32 = 95;
constant R_PARISC_LTOFF64 (line 1314) | pub const R_PARISC_LTOFF64: u32 = 96;
constant R_PARISC_LTOFF14WR (line 1315) | pub const R_PARISC_LTOFF14WR: u32 = 99;
constant R_PARISC_LTOFF14DR (line 1316) | pub const R_PARISC_LTOFF14DR: u32 = 100;
constant R_PARISC_LTOFF16F (line 1317) | pub const R_PARISC_LTOFF16F: u32 = 101;
constant R_PARISC_LTOFF16WF (line 1318) | pub const R_PARISC_LTOFF16WF: u32 = 102;
constant R_PARISC_LTOFF16DF (line 1319) | pub const R_PARISC_LTOFF16DF: u32 = 103;
constant R_PARISC_SECREL64 (line 1320) | pub const R_PARISC_SECREL64: u32 = 104;
constant R_PARISC_SEGREL64 (line 1321) | pub const R_PARISC_SEGREL64: u32 = 112;
constant R_PARISC_PLTOFF14WR (line 1322) | pub const R_PARISC_PLTOFF14WR: u32 = 115;
constant R_PARISC_PLTOFF14DR (line 1323) | pub const R_PARISC_PLTOFF14DR: u32 = 116;
constant R_PARISC_PLTOFF16F (line 1324) | pub const R_PARISC_PLTOFF16F: u32 = 117;
constant R_PARISC_PLTOFF16WF (line 1325) | pub const R_PARISC_PLTOFF16WF: u32 = 118;
constant R_PARISC_PLTOFF16DF (line 1326) | pub const R_PARISC_PLTOFF16DF: u32 = 119;
constant R_PARISC_LTOFF_FPTR64 (line 1327) | pub const R_PARISC_LTOFF_FPTR64: u32 = 120;
constant R_PARISC_LTOFF_FPTR14WR (line 1328) | pub const R_PARISC_LTOFF_FPTR14WR: u32 = 123;
constant R_PARISC_LTOFF_FPTR14DR (line 1329) | pub const R_PARISC_LTOFF_FPTR14DR: u32 = 124;
constant R_PARISC_LTOFF_FPTR16F (line 1330) | pub const R_PARISC_LTOFF_FPTR16F: u32 = 125;
constant R_PARISC_LTOFF_FPTR16WF (line 1331) | pub const R_PARISC_LTOFF_FPTR16WF: u32 = 126;
constant R_PARISC_LTOFF_FPTR16DF (line 1332) | pub const R_PARISC_LTOFF_FPTR16DF: u32 = 127;
constant R_PARISC_LORESERVE (line 1333) | pub const R_PARISC_LORESERVE: u32 = 128;
constant R_PARISC_COPY (line 1334) | pub const R_PARISC_COPY: u32 = 128;
constant R_PARISC_IPLT (line 1335) | pub const R_PARISC_IPLT: u32 = 129;
constant R_PARISC_EPLT (line 1336) | pub const R_PARISC_EPLT: u32 = 130;
constant R_PARISC_TPREL32 (line 1337) | pub const R_PARISC_TPREL32: u32 = 153;
constant R_PARISC_TPREL21L (line 1338) | pub const R_PARISC_TPREL21L: u32 = 154;
constant R_PARISC_TPREL14R (line 1339) | pub const R_PARISC_TPREL14R: u32 = 158;
constant R_PARISC_LTOFF_TP21L (line 1340) | pub const R_PARISC_LTOFF_TP21L: u32 = 162;
constant R_PARISC_LTOFF_TP14R (line 1341) | pub const R_PARISC_LTOFF_TP14R: u32 = 166;
constant R_PARISC_LTOFF_TP14F (line 1342) | pub const R_PARISC_LTOFF_TP14F: u32 = 167;
constant R_PARISC_TPREL64 (line 1343) | pub const R_PARISC_TPREL64: u32 = 216;
constant R_PARISC_TPREL14WR (line 1344) | pub const R_PARISC_TPREL14WR: u32 = 219;
constant R_PARISC_TPREL14DR (line 1345) | pub const R_PARISC_TPREL14DR: u32 = 220;
constant R_PARISC_TPREL16F (line 1346) | pub const R_PARISC_TPREL16F: u32 = 221;
constant R_PARISC_TPREL16WF (line 1347) | pub const R_PARISC_TPREL16WF: u32 = 222;
constant R_PARISC_TPREL16DF (line 1348) | pub const R_PARISC_TPREL16DF: u32 = 223;
constant R_PARISC_LTOFF_TP64 (line 1349) | pub const R_PARISC_LTOFF_TP64: u32 = 224;
constant R_PARISC_LTOFF_TP14WR (line 1350) | pub const R_PARISC_LTOFF_TP14WR: u32 = 227;
constant R_PARISC_LTOFF_TP14DR (line 1351) | pub const R_PARISC_LTOFF_TP14DR: u32 = 228;
constant R_PARISC_LTOFF_TP16F (line 1352) | pub const R_PARISC_LTOFF_TP16F: u32 = 229;
constant R_PARISC_LTOFF_TP16WF (line 1353) | pub const R_PARISC_LTOFF_TP16WF: u32 = 230;
constant R_PARISC_LTOFF_TP16DF (line 1354) | pub const R_PARISC_LTOFF_TP16DF: u32 = 231;
constant R_PARISC_GNU_VTENTRY (line 1355) | pub const R_PARISC_GNU_VTENTRY: u32 = 232;
constant R_PARISC_GNU_VTINHERIT (line 1356) | pub const R_PARISC_GNU_VTINHERIT: u32 = 233;
constant R_PARISC_TLS_GD21L (line 1357) | pub const R_PARISC_TLS_GD21L: u32 = 234;
constant R_PARISC_TLS_GD14R (line 1358) | pub const R_PARISC_TLS_GD14R: u32 = 235;
constant R_PARISC_TLS_GDCALL (line 1359) | pub const R_PARISC_TLS_GDCALL: u32 = 236;
constant R_PARISC_TLS_LDM21L (line 1360) | pub const R_PARISC_TLS_LDM21L: u32 = 237;
constant R_PARISC_TLS_LDM14R (line 1361) | pub const R_PARISC_TLS_LDM14R: u32 = 238;
constant R_PARISC_TLS_LDMCALL (line 1362) | pub const R_PARISC_TLS_LDMCALL: u32 = 239;
constant R_PARISC_TLS_LDO21L (line 1363) | pub const R_PARISC_TLS_LDO21L: u32 = 240;
constant R_PARISC_TLS_LDO14R (line 1364) | pub const R_PARISC_TLS_LDO14R: u32 = 241;
constant R_PARISC_TLS_DTPMOD32 (line 1365) | pub const R_PARISC_TLS_DTPMOD32: u32 = 242;
constant R_PARISC_TLS_DTPMOD64 (line 1366) | pub const R_PARISC_TLS_DTPMOD64: u32 = 243;
constant R_PARISC_TLS_DTPOFF32 (line 1367) | pub const R_PARISC_TLS_DTPOFF32: u32 = 244;
constant R_PARISC_TLS_DTPOFF64 (line 1368) | pub const R_PARISC_TLS_DTPOFF64: u32 = 245;
constant R_PARISC_TLS_LE21L (line 1369) | pub const R_PARISC_TLS_LE21L: u32 = 154;
constant R_PARISC_TLS_LE14R (line 1370) | pub const R_PARISC_TLS_LE14R: u32 = 158;
constant R_PARISC_TLS_IE21L (line 1371) | pub const R_PARISC_TLS_IE21L: u32 = 162;
constant R_PARISC_TLS_IE14R (line 1372) | pub const R_PARISC_TLS_IE14R: u32 = 166;
constant R_PARISC_TLS_TPREL32 (line 1373) | pub const R_PARISC_TLS_TPREL32: u32 = 153;
constant R_PARISC_TLS_TPREL64 (line 1374) | pub const R_PARISC_TLS_TPREL64: u32 = 216;
constant R_PARISC_HIRESERVE (line 1375) | pub const R_PARISC_HIRESERVE: u32 = 255;
constant PT_HP_TLS (line 1376) | pub const PT_HP_TLS: u32 = 1610612736;
constant PT_HP_CORE_NONE (line 1377) | pub const PT_HP_CORE_NONE: u32 = 1610612737;
constant PT_HP_CORE_VERSION (line 1378) | pub const PT_HP_CORE_VERSION: u32 = 1610612738;
constant PT_HP_CORE_KERNEL (line 1379) | pub const PT_HP_CORE_KERNEL: u32 = 1610612739;
constant PT_HP_CORE_COMM (line 1380) | pub const PT_HP_CORE_COMM: u32 = 1610612740;
constant PT_HP_CORE_PROC (line 1381) | pub const PT_HP_CORE_PROC: u32 = 1610612741;
constant PT_HP_CORE_LOADABLE (line 1382) | pub const PT_HP_CORE_LOADABLE: u32 = 1610612742;
constant PT_HP_CORE_STACK (line 1383) | pub const PT_HP_CORE_STACK: u32 = 1610612743;
constant PT_HP_CORE_SHM (line 1384) | pub const PT_HP_CORE_SHM: u32 = 1610612744;
constant PT_HP_CORE_MMF (line 1385) | pub const PT_HP_CORE_MMF: u32 = 1610612745;
constant PT_HP_PARALLEL (line 1386) | pub const PT_HP_PARALLEL: u32 = 1610612752;
constant PT_HP_FASTBIND (line 1387) | pub const PT_HP_FASTBIND: u32 = 1610612753;
constant PT_HP_OPT_ANNOT (line 1388) | pub const PT_HP_OPT_ANNOT: u32 = 1610612754;
constant PT_HP_HSL_ANNOT (line 1389) | pub const PT_HP_HSL_ANNOT: u32 = 1610612755;
constant PT_HP_STACK (line 1390) | pub const PT_HP_STACK: u32 = 1610612756;
constant PT_PARISC_ARCHEXT (line 1391) | pub const PT_PARISC_ARCHEXT: u32 = 1879048192;
constant PT_PARISC_UNWIND (line 1392) | pub const PT_PARISC_UNWIND: u32 = 1879048193;
constant PF_PARISC_SBP (line 1393) | pub const PF_PARISC_SBP: u32 = 134217728;
constant PF_HP_PAGE_SIZE (line 1394) | pub const PF_HP_PAGE_SIZE: u32 = 1048576;
constant PF_HP_FAR_SHARED (line 1395) | pub const PF_HP_FAR_SHARED: u32 = 2097152;
constant PF_HP_NEAR_SHARED (line 1396) | pub const PF_HP_NEAR_SHARED: u32 = 4194304;
constant PF_HP_CODE (line 1397) | pub const PF_HP_CODE: u32 = 16777216;
constant PF_HP_MODIFY (line 1398) | pub const PF_HP_MODIFY: u32 = 33554432;
constant PF_HP_LAZYSWAP (line 1399) | pub const PF_HP_LAZYSWAP: u32 = 67108864;
constant PF_HP_SBP (line 1400) | pub const PF_HP_SBP: u32 = 134217728;
constant EF_ALPHA_32BIT (line 1401) | pub const EF_ALPHA_32BIT: u32 = 1;
constant EF_ALPHA_CANRELAX (line 1402) | pub const EF_ALPHA_CANRELAX: u32 = 2;
constant SHT_ALPHA_DEBUG (line 1403) | pub const SHT_ALPHA_DEBUG: u32 = 1879048193;
constant SHT_ALPHA_REGINFO (line 1404) | pub const SHT_ALPHA_REGINFO: u32 = 1879048194;
constant SHF_ALPHA_GPREL (line 1405) | pub const SHF_ALPHA_GPREL: u32 = 268435456;
constant STO_ALPHA_NOPV (line 1406) | pub const STO_ALPHA_NOPV: u32 = 128;
constant STO_ALPHA_STD_GPLOAD (line 1407) | pub const STO_ALPHA_STD_GPLOAD: u32 = 136;
constant R_ALPHA_NONE (line 1408) | pub const R_ALPHA_NONE: u32 = 0;
constant R_ALPHA_REFLONG (line 1409) | pub const R_ALPHA_REFLONG: u32 = 1;
constant R_ALPHA_REFQUAD (line 1410) | pub const R_ALPHA_REFQUAD: u32 = 2;
constant R_ALPHA_GPREL32 (line 1411) | pub const R_ALPHA_GPREL32: u32 = 3;
constant R_ALPHA_LITERAL (line 1412) | pub const R_ALPHA_LITERAL: u32 = 4;
constant R_ALPHA_LITUSE (line 1413) | pub const R_ALPHA_LITUSE: u32 = 5;
constant R_ALPHA_GPDISP (line 1414) | pub const R_ALPHA_GPDISP: u32 = 6;
constant R_ALPHA_BRADDR (line 1415) | pub const R_ALPHA_BRADDR: u32 = 7;
constant R_ALPHA_HINT (line 1416) | pub const R_ALPHA_HINT: u32 = 8;
constant R_ALPHA_SREL16 (line 1417) | pub const R_ALPHA_SREL16: u32 = 9;
constant R_ALPHA_SREL32 (line 1418) | pub const R_ALPHA_SREL32: u32 = 10;
constant R_ALPHA_SREL64 (line 1419) | pub const R_ALPHA_SREL64: u32 = 11;
constant R_ALPHA_GPRELHIGH (line 1420) | pub const R_ALPHA_GPRELHIGH: u32 = 17;
constant R_ALPHA_GPRELLOW (line 1421) | pub const R_ALPHA_GPRELLOW: u32 = 18;
constant R_ALPHA_GPREL16 (line 1422) | pub const R_ALPHA_GPREL16: u32 = 19;
constant R_ALPHA_COPY (line 1423) | pub const R_ALPHA_COPY: u32 = 24;
constant R_ALPHA_GLOB_DAT (line 1424) | pub const R_ALPHA_GLOB_DAT: u32 = 25;
constant R_ALPHA_JMP_SLOT (line 1425) | pub const R_ALPHA_JMP_SLOT: u32 = 26;
constant R_ALPHA_RELATIVE (line 1426) | pub const R_ALPHA_RELATIVE: u32 = 27;
constant R_ALPHA_TLS_GD_HI (line 1427) | pub const R_ALPHA_TLS_GD_HI: u32 = 28;
constant R_ALPHA_TLSGD (line 1428) | pub const R_ALPHA_TLSGD: u32 = 29;
constant R_ALPHA_TLS_LDM (line 1429) | pub const R_ALPHA_TLS_LDM: u32 = 30;
constant R_ALPHA_DTPMOD64 (line 1430) | pub const R_ALPHA_DTPMOD64: u32 = 31;
constant R_ALPHA_GOTDTPREL (line 1431) | pub const R_ALPHA_GOTDTPREL: u32 = 32;
constant R_ALPHA_DTPREL64 (line 1432) | pub const R_ALPHA_DTPREL64: u32 = 33;
constant R_ALPHA_DTPRELHI (line 1433) | pub const R_ALPHA_DTPRELHI: u32 = 34;
constant R_ALPHA_DTPRELLO (line 1434) | pub const R_ALPHA_DTPRELLO: u32 = 35;
constant R_ALPHA_DTPREL16 (line 1435) | pub const R_ALPHA_DTPREL16: u32 = 36;
constant R_ALPHA_GOTTPREL (line 1436) | pub const R_ALPHA_GOTTPREL: u32 = 37;
constant R_ALPHA_TPREL64 (line 1437) | pub const R_ALPHA_TPREL64: u32 = 38;
constant R_ALPHA_TPRELHI (line 1438) | pub const R_ALPHA_TPRELHI: u32 = 39;
constant R_ALPHA_TPRELLO (line 1439) | pub const R_ALPHA_TPRELLO: u32 = 40;
constant R_ALPHA_TPREL16 (line 1440) | pub const R_ALPHA_TPREL16: u32 = 41;
constant R_ALPHA_NUM (line 1441) | pub const R_ALPHA_NUM: u32 = 46;
constant LITUSE_ALPHA_ADDR (line 1442) | pub const LITUSE_ALPHA_ADDR: u32 = 0;
constant LITUSE_ALPHA_BASE (line 1443) | pub const LITUSE_ALPHA_BASE: u32 = 1;
constant LITUSE_ALPHA_BYTOFF (line 1444) | pub const LITUSE_ALPHA_BYTOFF: u32 = 2;
constant LITUSE_ALPHA_JSR (line 1445) | pub const LITUSE_ALPHA_JSR: u32 = 3;
constant LITUSE_ALPHA_TLS_GD (line 1446) | pub const LITUSE_ALPHA_TLS_GD: u32 = 4;
constant LITUSE_ALPHA_TLS_LDM (line 1447) | pub const LITUSE_ALPHA_TLS_LDM: u32 = 5;
constant DT_ALPHA_PLTRO (line 1448) | pub const DT_ALPHA_PLTRO: u32 = 1879048192;
constant DT_ALPHA_NUM (line 1449) | pub const DT_ALPHA_NUM: u32 = 1;
constant EF_PPC_EMB (line 1450) | pub const EF_PPC_EMB: u32 = 2147483648;
constant EF_PPC_RELOCATABLE (line 1451) | pub const EF_PPC_RELOCATABLE: u32 = 65536;
constant EF_PPC_RELOCATABLE_LIB (line 1452) | pub const EF_PPC_RELOCATABLE_LIB: u32 = 32768;
constant R_PPC_NONE (line 1453) | pub const R_PPC_NONE: u32 = 0;
constant R_PPC_ADDR32 (line 1454) | pub const R_PPC_ADDR32: u32 = 1;
constant R_PPC_ADDR24 (line 1455) | pub const R_PPC_ADDR24: u32 = 2;
constant R_PPC_ADDR16 (line 1456) | pub const R_PPC_ADDR16: u32 = 3;
constant R_PPC_ADDR16_LO (line 1457) | pub const R_PPC_ADDR16_LO: u32 = 4;
constant R_PPC_ADDR16_HI (line 1458) | pub const R_PPC_ADDR16_HI: u32 = 5;
constant R_PPC_ADDR16_HA (line 1459) | pub const R_PPC_ADDR16_HA: u32 = 6;
constant R_PPC_ADDR14 (line 1460) | pub const R_PPC_ADDR14: u32 = 7;
constant R_PPC_ADDR14_BRTAKEN (line 1461) | pub const R_PPC_ADDR14_BRTAKEN: u32 = 8;
constant R_PPC_ADDR14_BRNTAKEN (line 1462) | pub const R_PPC_ADDR14_BRNTAKEN: u32 = 9;
constant R_PPC_REL24 (line 1463) | pub const R_PPC_REL24: u32 = 10;
constant R_PPC_REL14 (line 1464) | pub const R_PPC_REL14: u32 = 11;
constant R_PPC_REL14_BRTAKEN (line 1465) | pub const R_PPC_REL14_BRTAKEN: u32 = 12;
constant R_PPC_REL14_BRNTAKEN (line 1466) | pub const R_PPC_REL14_BRNTAKEN: u32 = 13;
constant R_PPC_GOT16 (line 1467) | pub const R_PPC_GOT16: u32 = 14;
constant R_PPC_GOT16_LO (line 1468) | pub const R_PPC_GOT16_LO: u32 = 15;
constant R_PPC_GOT16_HI (line 1469) | pub const R_PPC_GOT16_HI: u32 = 16;
constant R_PPC_GOT16_HA (line 1470) | pub const R_PPC_GOT16_HA: u32 = 17;
constant R_PPC_PLTREL24 (line 1471) | pub const R_PPC_PLTREL24: u32 = 18;
constant R_PPC_COPY (line 1472) | pub const R_PPC_COPY: u32 = 19;
constant R_PPC_GLOB_DAT (line 1473) | pub const R_PPC_GLOB_DAT: u32 = 20;
constant R_PPC_JMP_SLOT (line 1474) | pub const R_PPC_JMP_SLOT: u32 = 21;
constant R_PPC_RELATIVE (line 1475) | pub const R_PPC_RELATIVE: u32 = 22;
constant R_PPC_LOCAL24PC (line 1476) | pub const R_PPC_LOCAL24PC: u32 = 23;
constant R_PPC_UADDR32 (line 1477) | pub const R_PPC_UADDR32: u32 = 24;
constant R_PPC_UADDR16 (line 1478) | pub const R_PPC_UADDR16: u32 = 25;
constant R_PPC_REL32 (line 1479) | pub const R_PPC_REL32: u32 = 26;
constant R_PPC_PLT32 (line 1480) | pub const R_PPC_PLT32: u32 = 27;
constant R_PPC_PLTREL32 (line 1481) | pub const R_PPC_PLTREL32: u32 = 28;
constant R_PPC_PLT16_LO (line 1482) | pub const R_PPC_PLT16_LO: u32 = 29;
constant R_PPC_PLT16_HI (line 1483) | pub const R_PPC_PLT16_HI: u32 = 30;
constant R_PPC_PLT16_HA (line 1484) | pub const R_PPC_PLT16_HA: u32 = 31;
constant R_PPC_SDAREL16 (line 1485) | pub const R_PPC_SDAREL16: u32 = 32;
constant R_PPC_SECTOFF (line 1486) | pub const R_PPC_SECTOFF: u32 = 33;
constant R_PPC_SECTOFF_LO (line 1487) | pub const R_PPC_SECTOFF_LO: u32 = 34;
constant R_PPC_SECTOFF_HI (line 1488) | pub const R_PPC_SECTOFF_HI: u32 = 35;
constant R_PPC_SECTOFF_HA (line 1489) | pub const R_PPC_SECTOFF_HA: u32 = 36;
constant R_PPC_TLS (line 1490) | pub const R_PPC_TLS: u32 = 67;
constant R_PPC_DTPMOD32 (line 1491) | pub const R_PPC_DTPMOD32: u32 = 68;
constant R_PPC_TPREL16 (line 1492) | pub const R_PPC_TPREL16: u32 = 69;
constant R_PPC_TPREL16_LO (line 1493) | pub const R_PPC_TPREL16_LO: u32 = 70;
constant R_PPC_TPREL16_HI (line 1494) | pub const R_PPC_TPREL16_HI: u32 = 71;
constant R_PPC_TPREL16_HA (line 1495) | pub const R_PPC_TPREL16_HA: u32 = 72;
constant R_PPC_TPREL32 (line 1496) | pub const R_PPC_TPREL32: u32 = 73;
constant R_PPC_DTPREL16 (line 1497) | pub const R_PPC_DTPREL16: u32 = 74;
constant R_PPC_DTPREL16_LO (line 1498) | pub const R_PPC_DTPREL16_LO: u32 = 75;
constant R_PPC_DTPREL16_HI (line 1499) | pub const R_PPC_DTPREL16_HI: u32 = 76;
constant R_PPC_DTPREL16_HA (line 1500) | pub const R_PPC_DTPREL16_HA: u32 = 77;
constant R_PPC_DTPREL32 (line 1501) | pub const R_PPC_DTPREL32: u32 = 78;
constant R_PPC_GOT_TLSGD16 (line 1502) | pub const R_PPC_GOT_TLSGD16: u32 = 79;
constant R_PPC_GOT_TLSGD16_LO (line 1503) | pub const R_PPC_GOT_TLSGD16_LO: u32 = 80;
constant R_PPC_GOT_TLSGD16_HI (line 1504) | pub const R_PPC_GOT_TLSGD16_HI: u32 = 81;
constant R_PPC_GOT_TLSGD16_HA (line 1505) | pub const R_PPC_GOT_TLSGD16_HA: u32 = 82;
constant R_PPC_GOT_TLSLD16 (line 1506) | pub const R_PPC_GOT_TLSLD16: u32 = 83;
constant R_PPC_GOT_TLSLD16_LO (line 1507) | pub const R_PPC_GOT_TLSLD16_LO: u32 = 84;
constant R_PPC_GOT_TLSLD16_HI (line 1508) | pub const R_PPC_GOT_TLSLD16_HI: u32 = 85;
constant R_PPC_GOT_TLSLD16_HA (line 1509) | pub const R_PPC_GOT_TLSLD16_HA: u32 = 86;
constant R_PPC_GOT_TPREL16 (line 1510) | pub const R_PPC_GOT_TPREL16: u32 = 87;
constant R_PPC_GOT_TPREL16_LO (line 1511) | pub const R_PPC_GOT_TPREL16_LO: u32 = 88;
constant R_PPC_GOT_TPREL16_HI (line 1512) | pub const R_PPC_GOT_TPREL16_HI: u32 = 89;
constant R_PPC_GOT_TPREL16_HA (line 1513) | pub const R_PPC_GOT_TPREL16_HA: u32 = 90;
constant R_PPC_GOT_DTPREL16 (line 1514) | pub const R_PPC_GOT_DTPREL16: u32 = 91;
constant R_PPC_GOT_DTPREL16_LO (line 1515) | pub const R_PPC_GOT_DTPREL16_LO: u32 = 92;
constant R_PPC_GOT_DTPREL16_HI (line 1516) | pub const R_PPC_GOT_DTPREL16_HI: u32 = 93;
constant R_PPC_GOT_DTPREL16_HA (line 1517) | pub const R_PPC_GOT_DTPREL16_HA: u32 = 94;
constant R_PPC_TLSGD (line 1518) | pub const R_PPC_TLSGD: u32 = 95;
constant R_PPC_TLSLD (line 1519) | pub const R_PPC_TLSLD: u32 = 96;
constant R_PPC_EMB_NADDR32 (line 1520) | pub const R_PPC_EMB_NADDR32: u32 = 101;
constant R_PPC_EMB_NADDR16 (line 1521) | pub const R_PPC_EMB_NADDR16: u32 = 102;
constant R_PPC_EMB_NADDR16_LO (line 1522) | pub const R_PPC_EMB_NADDR16_LO: u32 = 103;
constant R_PPC_EMB_NADDR16_HI (line 1523) | pub const R_PPC_EMB_NADDR16_HI: u32 = 104;
constant R_PPC_EMB_NADDR16_HA (line 1524) | pub const R_PPC_EMB_NADDR16_HA: u32 = 105;
constant R_PPC_EMB_SDAI16 (line 1525) | pub const R_PPC_EMB_SDAI16: u32 = 106;
constant R_PPC_EMB_SDA2I16 (line 1526) | pub const R_PPC_EMB_SDA2I16: u32 = 107;
constant R_PPC_EMB_SDA2REL (line 1527) | pub const R_PPC_EMB_SDA2REL: u32 = 108;
constant R_PPC_EMB_SDA21 (line 1528) | pub const R_PPC_EMB_SDA21: u32 = 109;
constant R_PPC_EMB_MRKREF (line 1529) | pub const R_PPC_EMB_MRKREF: u32 = 110;
constant R_PPC_EMB_RELSEC16 (line 1530) | pub const R_PPC_EMB_RELSEC16: u32 = 111;
constant R_PPC_EMB_RELST_LO (line 1531) | pub const R_PPC_EMB_RELST_LO: u32 = 112;
constant R_PPC_EMB_RELST_HI (line 1532) | pub const R_PPC_EMB_RELST_HI: u32 = 113;
constant R_PPC_EMB_RELST_HA (line 1533) | pub const R_PPC_EMB_RELST_HA: u32 = 114;
constant R_PPC_EMB_BIT_FLD (line 1534) | pub const R_PPC_EMB_BIT_FLD: u32 = 115;
constant R_PPC_EMB_RELSDA (line 1535) | pub const R_PPC_EMB_RELSDA: u32 = 116;
constant R_PPC_DIAB_SDA21_LO (line 1536) | pub const R_PPC_DIAB_SDA21_LO: u32 = 180;
constant R_PPC_DIAB_SDA21_HI (line 1537) | pub const R_PPC_DIAB_SDA21_HI: u32 = 181;
constant R_PPC_DIAB_SDA21_HA (line 1538) | pub const R_PPC_DIAB_SDA21_HA: u32 = 182;
constant R_PPC_DIAB_RELSDA_LO (line 1539) | pub const R_PPC_DIAB_RELSDA_LO: u32 = 183;
constant R_PPC_DIAB_RELSDA_HI (line 1540) | pub const R_PPC_DIAB_RELSDA_HI: u32 = 184;
constant R_PPC_DIAB_RELSDA_HA (line 1541) | pub const R_PPC_DIAB_RELSDA_HA: u32 = 185;
constant R_PPC_IRELATIVE (line 1542) | pub const R_PPC_IRELATIVE: u32 = 248;
constant R_PPC_REL16 (line 1543) | pub const R_PPC_REL16: u32 = 249;
constant R_PPC_REL16_LO (line 1544) | pub const R_PPC_REL16_LO: u32 = 250;
constant R_PPC_REL16_HI (line 1545) | pub const R_PPC_REL16_HI: u32 = 251;
constant R_PPC_REL16_HA (line 1546) | pub const R_PPC_REL16_HA: u32 = 252;
constant R_PPC_TOC16 (line 1547) | pub const R_PPC_TOC16: u32 = 255;
constant DT_PPC_GOT (line 1548) | pub const DT_PPC_GOT: u32 = 1879048192;
constant DT_PPC_OPT (line 1549) | pub const DT_PPC_OPT: u32 = 1879048193;
constant DT_PPC_NUM (line 1550) | pub const DT_PPC_NUM: u32 = 2;
constant PPC_OPT_TLS (line 1551) | pub const PPC_OPT_TLS: u32 = 1;
constant R_PPC64_NONE (line 1552) | pub const R_PPC64_NONE: u32 = 0;
constant R_PPC64_ADDR32 (line 1553) | pub const R_PPC64_ADDR32: u32 = 1;
constant R_PPC64_ADDR24 (line 1554) | pub const R_PPC64_ADDR24: u32 = 2;
constant R_PPC64_ADDR16 (line 1555) | pub const R_PPC64_ADDR16: u32 = 3;
constant R_PPC64_ADDR16_LO (line 1556) | pub const R_PPC64_ADDR16_LO: u32 = 4;
constant R_PPC64_ADDR16_HI (line 1557) | pub const R_PPC64_ADDR16_HI: u32 = 5;
constant R_PPC64_ADDR16_HA (line 1558) | pub const R_PPC64_ADDR16_HA: u32 = 6;
constant R_PPC64_ADDR14 (line 1559) | pub const R_PPC64_ADDR14: u32 = 7;
constant R_PPC64_ADDR14_BRTAKEN (line 1560) | pub const R_PPC64_ADDR14_BRTAKEN: u32 = 8;
constant R_PPC64_ADDR14_BRNTAKEN (line 1561) | pub const R_PPC64_ADDR14_BRNTAKEN: u32 = 9;
constant R_PPC64_REL24 (line 1562) | pub const R_PPC64_REL24: u32 = 10;
constant R_PPC64_REL14 (line 1563) | pub const R_PPC64_REL14: u32 = 11;
constant R_PPC64_REL14_BRTAKEN (line 1564) | pub const R_PPC64_REL14_BRTAKEN: u32 = 12;
constant R_PPC64_REL14_BRNTAKEN (line 1565) | pub const R_PPC64_REL14_BRNTAKEN: u32 = 13;
constant R_PPC64_GOT16 (line 1566) | pub const R_PPC64_GOT16: u32 = 14;
constant R_PPC64_GOT16_LO (line 1567) | pub const R_PPC64_GOT16_LO: u32 = 15;
constant R_PPC64_GOT16_HI (line 1568) | pub const R_PPC64_GOT16_HI: u32 = 16;
constant R_PPC64_GOT16_HA (line 1569) | pub const R_PPC64_GOT16_HA: u32 = 17;
constant R_PPC64_COPY (line 1570) | pub const R_PPC64_COPY: u32 = 19;
constant R_PPC64_GLOB_DAT (line 1571) | pub const R_PPC64_GLOB_DAT: u32 = 20;
constant R_PPC64_JMP_SLOT (line 1572) | pub const R_PPC64_JMP_SLOT: u32 = 21;
constant R_PPC64_RELATIVE (line 1573) | pub const R_PPC64_RELATIVE: u32 = 22;
constant R_PPC64_UADDR32 (line 1574) | pub const R_PPC64_UADDR32: u32 = 24;
constant R_PPC64_UADDR16 (line 1575) | pub const R_PPC64_UADDR16: u32 = 25;
constant R_PPC64_REL32 (line 1576) | pub const R_PPC64_REL32: u32 = 26;
constant R_PPC64_PLT32 (line 1577) | pub const R_PPC64_PLT32: u32 = 27;
constant R_PPC64_PLTREL32 (line 1578) | pub const R_PPC64_PLTREL32: u32 = 28;
constant R_PPC64_PLT16_LO (line 1579) | pub const R_PPC64_PLT16_LO: u32 = 29;
constant R_PPC64_PLT16_HI (line 1580) | pub const R_PPC64_PLT16_HI: u32 = 30;
constant R_PPC64_PLT16_HA (line 1581) | pub const R_PPC64_PLT16_HA: u32 = 31;
constant R_PPC64_SECTOFF (line 1582) | pub const R_PPC64_SECTOFF: u32 = 33;
constant R_PPC64_SECTOFF_LO (line 1583) | pub const R_PPC64_SECTOFF_LO: u32 = 34;
constant R_PPC64_SECTOFF_HI (line 1584) | pub const R_PPC64_SECTOFF_HI: u32 = 35;
constant R_PPC64_SECTOFF_HA (line 1585) | pub const R_PPC64_SECTOFF_HA: u32 = 36;
constant R_PPC64_ADDR30 (line 1586) | pub const R_PPC64_ADDR30: u32 = 37;
constant R_PPC64_ADDR64 (line 1587) | pub const R_PPC64_ADDR64: u32 = 38;
constant R_PPC64_ADDR16_HIGHER (line 1588) | pub const R_PPC64_ADDR16_HIGHER: u32 = 39;
constant R_PPC64_ADDR16_HIGHERA (line 1589) | pub const R_PPC64_ADDR16_HIGHERA: u32 = 40;
constant R_PPC64_ADDR16_HIGHEST (line 1590) | pub const R_PPC64_ADDR16_HIGHEST: u32 = 41;
constant R_PPC64_ADDR16_HIGHESTA (line 1591) | pub const R_PPC64_ADDR16_HIGHESTA: u32 = 42;
constant R_PPC64_UADDR64 (line 1592) | pub const R_PPC64_UADDR64: u32 = 43;
constant R_PPC64_REL64 (line 1593) | pub const R_PPC64_REL64: u32 = 44;
constant R_PPC64_PLT64 (line 1594) | pub const R_PPC64_PLT64: u32 = 45;
constant R_PPC64_PLTREL64 (line 1595) | pub const R_PPC64_PLTREL64: u32 = 46;
constant R_PPC64_TOC16 (line 1596) | pub const R_PPC64_TOC16: u32 = 47;
constant R_PPC64_TOC16_LO (line 1597) | pub const R_PPC64_TOC16_LO: u32 = 48;
constant R_PPC64_TOC16_HI (line 1598) | pub const R_PPC64_TOC16_HI: u32 = 49;
constant R_PPC64_TOC16_HA (line 1599) | pub const R_PPC64_TOC16_HA: u32 = 50;
constant R_PPC64_TOC (line 1600) | pub const R_PPC64_TOC: u32 = 51;
constant R_PPC64_PLTGOT16 (line 1601) | pub const R_PPC64_PLTGOT16: u32 = 52;
constant R_PPC64_PLTGOT16_LO (line 1602) | pub const R_PPC64_PLTGOT16_LO: u32 = 53;
constant R_PPC64_PLTGOT16_HI (line 1603) | pub const R_PPC64_PLTGOT16_HI: u32 = 54;
constant R_PPC64_PLTGOT16_HA (line 1604) | pub const R_PPC64_PLTGOT16_HA: u32 = 55;
constant R_PPC64_ADDR16_DS (line 1605) | pub const R_PPC64_ADDR16_DS: u32 = 56;
constant R_PPC64_ADDR16_LO_DS (line 1606) | pub const R_PPC64_ADDR16_LO_DS: u32 = 57;
constant R_PPC64_GOT16_DS (line 1607) | pub const R_PPC64_GOT16_DS: u32 = 58;
constant R_PPC64_GOT16_LO_DS (line 1608) | pub const R_PPC64_GOT16_LO_DS: u32 = 59;
constant R_PPC64_PLT16_LO_DS (line 1609) | pub const R_PPC64_PLT16_LO_DS: u32 = 60;
constant R_PPC64_SECTOFF_DS (line 1610) | pub const R_PPC64_SECTOFF_DS: u32 = 61;
constant R_PPC64_SECTOFF_LO_DS (line 1611) | pub const R_PPC64_SECTOFF_LO_DS: u32 = 62;
constant R_PPC64_TOC16_DS (line 1612) | pub const R_PPC64_TOC16_DS: u32 = 63;
constant R_PPC64_TOC16_LO_DS (line 1613) | pub const R_PPC64_TOC16_LO_DS: u32 = 64;
constant R_PPC64_PLTGOT16_DS (line 1614) | pub const R_PPC64_PLTGOT16_DS: u32 = 65;
constant R_PPC64_PLTGOT16_LO_DS (line 1615) | pub const R_PPC64_PLTGOT16_LO_DS: u32 = 66;
constant R_PPC64_TLS (line 1616) | pub const R_PPC64_TLS: u32 = 67;
constant R_PPC64_DTPMOD64 (line 1617) | pub const R_PPC64_DTPMOD64: u32 = 68;
constant R_PPC64_TPREL16 (line 1618) | pub const R_PPC64_TPREL16: u32 = 69;
constant R_PPC64_TPREL16_LO (line 1619) | pub const R_PPC64_TPREL16_LO: u32 = 70;
constant R_PPC64_TPREL16_HI (line 1620) | pub const R_PPC64_TPREL16_HI: u32 = 71;
constant R_PPC64_TPREL16_HA (line 1621) | pub const R_PPC64_TPREL16_HA: u32 = 72;
constant R_PPC64_TPREL64 (line 1622) | pub const R_PPC64_TPREL64: u32 = 73;
constant R_PPC64_DTPREL16 (line 1623) | pub const R_PPC64_DTPREL16: u32 = 74;
constant R_PPC64_DTPREL16_LO (line 1624) | pub const R_PPC64_DTPREL16_LO: u32 = 75;
constant R_PPC64_DTPREL16_HI (line 1625) | pub const R_PPC64_DTPREL16_HI: u32 = 76;
constant R_PPC64_DTPREL16_HA (line 1626) | pub const R_PPC64_DTPREL16_HA: u32 = 77;
constant R_PPC64_DTPREL64 (line 1627) | pub const R_PPC64_DTPREL64: u32 = 78;
constant R_PPC64_GOT_TLSGD16 (line 1628) | pub const R_PPC64_GOT_TLSGD16: u32 = 79;
constant R_PPC64_GOT_TLSGD16_LO (line 1629) | pub const R_PPC64_GOT_TLSGD16_LO: u32 = 80;
constant R_PPC64_GOT_TLSGD16_HI (line 1630) | pub const R_PPC64_GOT_TLSGD16_HI: u32 = 81;
constant R_PPC64_GOT_TLSGD16_HA (line 1631) | pub const R_PPC64_GOT_TLSGD16_HA: u32 = 82;
constant R_PPC64_GOT_TLSLD16 (line 1632) | pub const R_PPC64_GOT_TLSLD16: u32 = 83;
constant R_PPC64_GOT_TLSLD16_LO (line 1633) | pub const R_PPC64_GOT_TLSLD16_LO: u32 = 84;
constant R_PPC64_GOT_TLSLD16_HI (line 1634) | pub const R_PPC64_GOT_TLSLD16_HI: u32 = 85;
constant R_PPC64_GOT_TLSLD16_HA (line 1635) | pub const R_PPC64_GOT_TLSLD16_HA: u32 = 86;
constant R_PPC64_GOT_TPREL16_DS (line 1636) | pub const R_PPC64_GOT_TPREL16_DS: u32 = 87;
constant R_PPC64_GOT_TPREL16_LO_DS (line 1637) | pub const R_PPC64_GOT_TPREL16_LO_DS: u32 = 88;
constant R_PPC64_GOT_TPREL16_HI (line 1638) | pub const R_PPC64_GOT_TPREL16_HI: u32 = 89;
constant R_PPC64_GOT_TPREL16_HA (line 1639) | pub const R_PPC64_GOT_TPREL16_HA: u32 = 90;
constant R_PPC64_GOT_DTPREL16_DS (line 1640) | pub const R_PPC64_GOT_DTPREL16_DS: u32 = 91;
constant R_PPC64_GOT_DTPREL16_LO_DS (line 1641) | pub const R_PPC64_GOT_DTPREL16_LO_DS: u32 = 92;
constant R_PPC64_GOT_DTPREL16_HI (line 1642) | pub const R_PPC64_GOT_DTPREL16_HI: u32 = 93;
constant R_PPC64_GOT_DTPREL16_HA (line 1643) | pub const R_PPC64_GOT_DTPREL16_HA: u32 = 94;
constant R_PPC64_TPREL16_DS (line 1644) | pub const R_PPC64_TPREL16_DS: u32 = 95;
constant R_PPC64_TPREL16_LO_DS (line 1645) | pub const R_PPC64_TPREL16_LO_DS: u32 = 96;
constant R_PPC64_TPREL16_HIGHER (line 1646) | pub const R_PPC64_TPREL16_HIGHER: u32 = 97;
constant R_PPC64_TPREL16_HIGHERA (line 1647) | pub const R_PPC64_TPREL16_HIGHERA: u32 = 98;
constant R_PPC64_TPREL16_HIGHEST (line 1648) | pub const R_PPC64_TPREL16_HIGHEST: u32 = 99;
constant R_PPC64_TPREL16_HIGHESTA (line 1649) | pub const R_PPC64_TPREL16_HIGHESTA: u32 = 100;
constant R_PPC64_DTPREL16_DS (line 1650) | pub const R_PPC64_DTPREL16_DS: u32 = 101;
constant R_PPC64_DTPREL16_LO_DS (line 1651) | pub const R_PPC64_DTPREL16_LO_DS: u32 = 102;
constant R_PPC64_DTPREL16_HIGHER (line 1652) | pub const R_PPC64_DTPREL16_HIGHER: u32 = 103;
constant R_PPC64_DTPREL16_HIGHERA (line 1653) | pub const R_PPC64_DTPREL16_HIGHERA: u32 = 104;
constant R_PPC64_DTPREL16_HIGHEST (line 1654) | pub const R_PPC64_DTPREL16_HIGHEST: u32 = 105;
constant R_PPC64_DTPREL16_HIGHESTA (line 1655) | pub const R_PPC64_DTPREL16_HIGHESTA: u32 = 106;
constant R_PPC64_TLSGD (line 1656) | pub const R_PPC64_TLSGD: u32 = 107;
constant R_PPC64_TLSLD (line 1657) | pub const R_PPC64_TLSLD: u32 = 108;
constant R_PPC64_TOCSAVE (line 1658) | pub const R_PPC64_TOCSAVE: u32 = 109;
constant R_PPC64_ADDR16_HIGH (line 1659) | pub const R_PPC64_ADDR16_HIGH: u32 = 110;
constant R_PPC64_ADDR16_HIGHA (line 1660) | pub const R_PPC64_ADDR16_HIGHA: u32 = 111;
constant R_PPC64_TPREL16_HIGH (line 1661) | pub const R_PPC64_TPREL16_HIGH: u32 = 112;
constant R_PPC64_TPREL16_HIGHA (line 1662) | pub const R_PPC64_TPREL16_HIGHA: u32 = 113;
constant R_PPC64_DTPREL16_HIGH (line 1663) | pub const R_PPC64_DTPREL16_HIGH: u32 = 114;
constant R_PPC64_DTPREL16_HIGHA (line 1664) | pub const R_PPC64_DTPREL16_HIGHA: u32 = 115;
constant R_PPC64_JMP_IREL (line 1665) | pub const R_PPC64_JMP_IREL: u32 = 247;
constant R_PPC64_IRELATIVE (line 1666) | pub const R_PPC64_IRELATIVE: u32 = 248;
constant R_PPC64_REL16 (line 1667) | pub const R_PPC64_REL16: u32 = 249;
constant R_PPC64_REL16_LO (line 1668) | pub const R_PPC64_REL16_LO: u32 = 250;
constant R_PPC64_REL16_HI (line 1669) | pub const R_PPC64_REL16_HI: u32 = 251;
constant R_PPC64_REL16_HA (line 1670) | pub const R_PPC64_REL16_HA: u32 = 252;
constant EF_PPC64_ABI (line 1671) | pub const EF_PPC64_ABI: u32 = 3;
constant DT_PPC64_GLINK (line 1672) | pub const DT_PPC64_GLINK: u32 = 1879048192;
constant DT_PPC64_OPD (line 1673) | pub const DT_PPC64_OPD: u32 = 1879048193;
constant DT_PPC64_OPDSZ (line 1674) | pub const DT_PPC64_OPDSZ: u32 = 1879048194;
constant DT_PPC64_OPT (line 1675) | pub const DT_PPC64_OPT: u32 = 1879048195;
constant DT_PPC64_NUM (line 1676) | pub const DT_PPC64_NUM: u32 = 4;
constant PPC64_OPT_TLS (line 1677) | pub const PPC64_OPT_TLS: u32 = 1;
constant PPC64_OPT_MULTI_TOC (line 1678) | pub const PPC64_OPT_MULTI_TOC: u32 = 2;
constant PPC64_OPT_LOCALENTRY (line 1679) | pub const PPC64_OPT_LOCALENTRY: u32 = 4;
constant STO_PPC64_LOCAL_BIT (line 1680) | pub const STO_PPC64_LOCAL_BIT: u32 = 5;
constant STO_PPC64_LOCAL_MASK (line 1681) | pub const STO_PPC64_LOCAL_MASK: u32 = 224;
constant EF_ARM_RELEXEC (line 1682) | pub const EF_ARM_RELEXEC: u32 = 1;
constant EF_ARM_HASENTRY (line 1683) | pub const EF_ARM_HASENTRY: u32 = 2;
constant EF_ARM_INTERWORK (line 1684) | pub const EF_ARM_INTERWORK: u32 = 4;
constant EF_ARM_APCS_26 (line 1685) | pub const EF_ARM_APCS_26: u32 = 8;
constant EF_ARM_APCS_FLOAT (line 1686) | pub const EF_ARM_APCS_FLOAT: u32 = 16;
constant EF_ARM_PIC (line 1687) | pub const EF_ARM_PIC: u32 = 32;
constant EF_ARM_ALIGN8 (line 1688) | pub const EF_ARM_ALIGN8: u32 = 64;
constant EF_ARM_NEW_ABI (line 1689) | pub const EF_ARM_NEW_ABI: u32 = 128;
constant EF_ARM_OLD_ABI (line 1690) | pub const EF_ARM_OLD_ABI: u32 = 256;
constant EF_ARM_SOFT_FLOAT (line 1691) | pub const EF_ARM_SOFT_FLOAT: u32 = 512;
constant EF_ARM_VFP_FLOAT (line 1692) | pub const EF_ARM_VFP_FLOAT: u32 = 1024;
constant EF_ARM_MAVERICK_FLOAT (line 1693) | pub const EF_ARM_MAVERICK_FLOAT: u32 = 2048;
constant EF_ARM_ABI_FLOAT_SOFT (line 1694) | pub const EF_ARM_ABI_FLOAT_SOFT: u32 = 512;
constant EF_ARM_ABI_FLOAT_HARD (line 1695) | pub const EF_ARM_ABI_FLOAT_HARD: u32 = 1024;
constant EF_ARM_SYMSARESORTED (line 1696) | pub const EF_ARM_SYMSARESORTED: u32 = 4;
constant EF_ARM_DYNSYMSUSESEGIDX (line 1697) | pub const EF_ARM_DYNSYMSUSESEGIDX: u32 = 8;
constant EF_ARM_MAPSYMSFIRST (line 1698) | pub const EF_ARM_MAPSYMSFIRST: u32 = 16;
constant EF_ARM_BE8 (line 1699) | pub const EF_ARM_BE8: u32 = 8388608;
constant EF_ARM_LE8 (line 1700) | pub const EF_ARM_LE8: u32 = 4194304;
constant EF_ARM_EABI_UNKNOWN (line 1701) | pub const EF_ARM_EABI_UNKNOWN: u32 = 0;
constant EF_ARM_EABI_VER1 (line 1702) | pub const EF_ARM_EABI_VER1: u32 = 16777216;
constant EF_ARM_EABI_VER2 (line 1703) | pub const EF_ARM_EABI_VER2: u32 = 33554432;
constant EF_ARM_EABI_VER3 (line 1704) | pub const EF_ARM_EABI_VER3: u32 = 50331648;
constant EF_ARM_EABI_VER4 (line 1705) | pub const EF_ARM_EABI_VER4: u32 = 67108864;
constant EF_ARM_EABI_VER5 (line 1706) | pub const EF_ARM_EABI_VER5: u32 = 83886080;
constant STT_ARM_TFUNC (line 1707) | pub const STT_ARM_TFUNC: u32 = 13;
constant STT_ARM_16BIT (line 1708) | pub const STT_ARM_16BIT: u32 = 15;
constant SHF_ARM_ENTRYSECT (line 1709) | pub const SHF_ARM_ENTRYSECT: u32 = 268435456;
constant SHF_ARM_COMDEF (line 1710) | pub const SHF_ARM_COMDEF: u32 = 2147483648;
constant PF_ARM_SB (line 1711) | pub const PF_ARM_SB: u32 = 268435456;
constant PF_ARM_PI (line 1712) | pub const PF_ARM_PI: u32 = 536870912;
constant PF_ARM_ABS (line 1713) | pub const PF_ARM_ABS: u32 = 1073741824;
constant PT_ARM_EXIDX (line 1714) | pub const PT_ARM_EXIDX: u32 = 1879048193;
constant SHT_ARM_EXIDX (line 1715) | pub const SHT_ARM_EXIDX: u32 = 1879048193;
constant SHT_ARM_PREEMPTMAP (line 1716) | pub const SHT_ARM_PREEMPTMAP: u32 = 1879048194;
constant SHT_ARM_ATTRIBUTES (line 1717) | pub const SHT_ARM_ATTRIBUTES: u32 = 1879048195;
constant R_AARCH64_NONE (line 1718) | pub const R_AARCH64_NONE: u32 = 0;
constant R_AARCH64_P32_ABS32 (line 1719) | pub const R_AARCH64_P32_ABS32: u32 = 1;
constant R_AARCH64_P32_COPY (line 1720) | pub const R_AARCH64_P32_COPY: u32 = 180;
constant R_AARCH64_P32_GLOB_DAT (line 1721) | pub const R_AARCH64_P32_GLOB_DAT: u32 = 181;
constant R_AARCH64_P32_JUMP_SLOT (line 1722) | pub const R_AARCH64_P32_JUMP_SLOT: u32 = 182;
constant R_AARCH64_P32_RELATIVE (line 1723) | pub const R_AARCH64_P32_RELATIVE: u32 = 183;
constant R_AARCH64_P32_TLS_DTPMOD (line 1724) | pub const R_AARCH64_P32_TLS_DTPMOD: u32 = 184;
constant R_AARCH64_P32_TLS_DTPREL (line 1725) | pub const R_AARCH64_P32_TLS_DTPREL: u32 = 185;
constant R_AARCH64_P32_TLS_TPREL (line 1726) | pub const R_AARCH64_P32_TLS_TPREL: u32 = 186;
constant R_AARCH64_P32_TLSDESC (line 1727) | pub const R_AARCH64_P32_TLSDESC: u32 = 187;
constant R_AARCH64_P32_IRELATIVE (line 1728) | pub const R_AARCH64_P32_IRELATIVE: u32 = 188;
constant R_AARCH64_ABS64 (line 1729) | pub const R_AARCH64_ABS64: u32 = 257;
constant R_AARCH64_ABS32 (line 1730) | pub const R_AARCH64_ABS32: u32 = 258;
constant R_AARCH64_ABS16 (line 1731) | pub const R_AARCH64_ABS16: u32 = 259;
constant R_AARCH64_PREL64 (line 1732) | pub const R_AARCH64_PREL64: u32 = 260;
constant R_AARCH64_PREL32 (line 1733) | pub const R_AARCH64_PREL32: u32 = 261;
constant R_AARCH64_PREL16 (line 1734) | pub const R_AARCH64_PREL16: u32 = 262;
constant R_AARCH64_MOVW_UABS_G0 (line 1735) | pub const R_AARCH64_MOVW_UABS_G0: u32 = 263;
constant R_AARCH64_MOVW_UABS_G0_NC (line 1736) | pub const R_AARCH64_MOVW_UABS_G0_NC: u32 = 264;
constant R_AARCH64_MOVW_UABS_G1 (line 1737) | pub const R_AARCH64_MOVW_UABS_G1: u32 = 265;
constant R_AARCH64_MOVW_UABS_G1_NC (line 1738) | pub const R_AARCH64_MOVW_UABS_G1_NC: u32 = 266;
constant R_AARCH64_MOVW_UABS_G2 (line 1739) | pub const R_AARCH64_MOVW_UABS_G2: u32 = 267;
constant R_AARCH64_MOVW_UABS_G2_NC (line 1740) | pub const R_AARCH64_MOVW_UABS_G2_NC: u32 = 268;
constant R_AARCH64_MOVW_UABS_G3 (line 1741) | pub const R_AARCH64_MOVW_UABS_G3: u32 = 269;
constant R_AARCH64_MOVW_SABS_G0 (line 1742) | pub const R_AARCH64_MOVW_SABS_G0: u32 = 270;
constant R_AARCH64_MOVW_SABS_G1 (line 1743) | pub const R_AARCH64_MOVW_SABS_G1: u32 = 271;
constant R_AARCH64_MOVW_SABS_G2 (line 1744) | pub const R_AARCH64_MOVW_SABS_G2: u32 = 272;
constant R_AARCH64_LD_PREL_LO19 (line 1745) | pub const R_AARCH64_LD_PREL_LO19: u32 = 273;
constant R_AARCH64_ADR_PREL_LO21 (line 1746) | pub const R_AARCH64_ADR_PREL_LO21: u32 = 274;
constant R_AARCH64_ADR_PREL_PG_HI21 (line 1747) | pub const R_AARCH64_ADR_PREL_PG_HI21: u32 = 275;
constant R_AARCH64_ADR_PREL_PG_HI21_NC (line 1748) | pub const R_AARCH64_ADR_PREL_PG_HI21_NC: u32 = 276;
constant R_AARCH64_ADD_ABS_LO12_NC (line 1749) | pub const R_AARCH64_ADD_ABS_LO12_NC: u32 = 277;
constant R_AARCH64_LDST8_ABS_LO12_NC (line 1750) | pub const R_AARCH64_LDST8_ABS_LO12_NC: u32 = 278;
constant R_AARCH64_TSTBR14 (line 1751) | pub const R_AARCH64_TSTBR14: u32 = 279;
constant R_AARCH64_CONDBR19 (line 1752) | pub const R_AARCH64_CONDBR19: u32 = 280;
constant R_AARCH64_JUMP26 (line 1753) | pub const R_AARCH64_JUMP26: u32 = 282;
constant R_AARCH64_CALL26 (line 1754) | pub const R_AARCH64_CALL26: u32 = 283;
constant R_AARCH64_LDST16_ABS_LO12_NC (line 1755) | pub const R_AARCH64_LDST16_ABS_LO12_NC: u32 = 284;
constant R_AARCH64_LDST32_ABS_LO12_NC (line 1756) | pub const R_AARCH64_LDST32_ABS_LO12_NC: u32 = 285;
constant R_AARCH64_LDST64_ABS_LO12_NC (line 1757) | pub const R_AARCH64_LDST64_ABS_LO12_NC: u32 = 286;
constant R_AARCH64_MOVW_PREL_G0 (line 1758) | pub const R_AARCH64_MOVW_PREL_G0: u32 = 287;
constant R_AARCH64_MOVW_PREL_G0_NC (line 1759) | pub const R_AARCH64_MOVW_PREL_G0_NC: u32 = 288;
constant R_AARCH64_MOVW_PREL_G1 (line 1760) | pub const R_AARCH64_MOVW_PREL_G1: u32 = 289;
constant R_AARCH64_MOVW_PREL_G1_NC (line 1761) | pub const R_AARCH64_MOVW_PREL_G1_NC: u32 = 290;
constant R_AARCH64_MOVW_PREL_G2 (line 1762) | pub const R_AARCH64_MOVW_PREL_G2: u32 = 291;
constant R_AARCH64_MOVW_PREL_G2_NC (line 1763) | pub const R_AARCH64_MOVW_PREL_G2_NC: u32 = 292;
constant R_AARCH64_MOVW_PREL_G3 (line 1764) | pub const R_AARCH64_MOVW_PREL_G3: u32 = 293;
constant R_AARCH64_LDST128_ABS_LO12_NC (line 1765) | pub const R_AARCH64_LDST128_ABS_LO12_NC: u32 = 299;
constant R_AARCH64_MOVW_GOTOFF_G0 (line 1766) | pub const R_AARCH64_MOVW_GOTOFF_G0: u32 = 300;
constant R_AARCH64_MOVW_GOTOFF_G0_NC (line 1767) | pub const R_AARCH64_MOVW_GOTOFF_G0_NC: u32 = 301;
constant R_AARCH64_MOVW_GOTOFF_G1 (line 1768) | pub const R_AARCH64_MOVW_GOTOFF_G1: u32 = 302;
constant R_AARCH64_MOVW_GOTOFF_G1_NC (line 1769) | pub const R_AARCH64_MOVW_GOTOFF_G1_NC: u32 = 303;
constant R_AARCH64_MOVW_GOTOFF_G2 (line 1770) | pub const R_AARCH64_MOVW_GOTOFF_G2: u32 = 304;
constant R_AARCH64_MOVW_GOTOFF_G2_NC (line 1771) | pub const R_AARCH64_MOVW_GOTOFF_G2_NC: u32 = 305;
constant R_AARCH64_MOVW_GOTOFF_G3 (line 1772) | pub const R_AARCH64_MOVW_GOTOFF_G3: u32 = 306;
constant R_AARCH64_GOTREL64 (line 1773) | pub const R_AARCH64_GOTREL64: u32 = 307;
constant R_AARCH64_GOTREL32 (line 1774) | pub const R_AARCH64_GOTREL32: u32 = 308;
constant R_AARCH64_GOT_LD_PREL19 (line 1775) | pub const R_AARCH64_GOT_LD_PREL19: u32 = 309;
constant R_AARCH64_LD64_GOTOFF_LO15 (line 1776) | pub const R_AARCH64_LD64_GOTOFF_LO15: u32 = 310;
constant R_AARCH64_ADR_GOT_PAGE (line 1777) | pub const R_AARCH64_ADR_GOT_PAGE: u32 = 311;
constant R_AARCH64_LD64_GOT_LO12_NC (line 1778) | pub const R_AARCH64_LD64_GOT_LO12_NC: u32 = 312;
constant R_AARCH64_LD64_GOTPAGE_LO15 (line 1779) | pub const R_AARCH64_LD64_GOTPAGE_LO15: u32 = 313;
constant R_AARCH64_TLSGD_ADR_PREL21 (line 1780) | pub const R_AARCH64_TLSGD_ADR_PREL21: u32 = 512;
constant R_AARCH64_TLSGD_ADR_PAGE21 (line 1781) | pub const R_AARCH64_TLSGD_ADR_PAGE21: u32 = 513;
constant R_AARCH64_TLSGD_ADD_LO12_NC (line 1782) | pub const R_AARCH64_TLSGD_ADD_LO12_NC: u32 = 514;
constant R_AARCH64_TLSGD_MOVW_G1 (line 1783) | pub const R_AARCH64_TLSGD_MOVW_G1: u32 = 515;
constant R_AARCH64_TLSGD_MOVW_G0_NC (line 1784) | pub const R_AARCH64_TLSGD_MOVW_G0_NC: u32 = 516;
constant R_AARCH64_TLSLD_ADR_PREL21 (line 1785) | pub const R_AARCH64_TLSLD_ADR_PREL21: u32 = 517;
constant R_AARCH64_TLSLD_ADR_PAGE21 (line 1786) | pub const R_AARCH64_TLSLD_ADR_PAGE21: u32 = 518;
constant R_AARCH64_TLSLD_ADD_LO12_NC (line 1787) | pub const R_AARCH64_TLSLD_ADD_LO12_NC: u32 = 519;
constant R_AARCH64_TLSLD_MOVW_G1 (line 1788) | pub const R_AARCH64_TLSLD_MOVW_G1: u32 = 520;
constant R_AARCH64_TLSLD_MOVW_G0_NC (line 1789) | pub const R_AARCH64_TLSLD_MOVW_G0_NC: u32 = 521;
constant R_AARCH64_TLSLD_LD_PREL19 (line 1790) | pub const R_AARCH64_TLSLD_LD_PREL19: u32 = 522;
constant R_AARCH64_TLSLD_MOVW_DTPREL_G2 (line 1791) | pub const R_AARCH64_TLSLD_MOVW_DTPREL_G2: u32 = 523;
constant R_AARCH64_TLSLD_MOVW_DTPREL_G1 (line 1792) | pub const R_AARCH64_TLSLD_MOVW_DTPREL_G1: u32 = 524;
constant R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC (line 1793) | pub const R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC: u32 = 525;
constant R_AARCH64_TLSLD_MOVW_DTPREL_G0 (line 1794) | pub const R_AARCH64_TLSLD_MOVW_DTPREL_G0: u32 = 526;
constant R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC (line 1795) | pub const R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC: u32 = 527;
constant R_AARCH64_TLSLD_ADD_DTPREL_HI12 (line 1796) | pub const R_AARCH64_TLSLD_ADD_DTPREL_HI12: u32 = 528;
constant R_AARCH64_TLSLD_ADD_DTPREL_LO12 (line 1797) | pub const R_AARCH64_TLSLD_ADD_DTPREL_LO12: u32 = 529;
constant R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC (line 1798) | pub const R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC: u32 = 530;
constant R_AARCH64_TLSLD_LDST8_DTPREL_LO12 (line 1799) | pub const R_AARCH64_TLSLD_LDST8_DTPREL_LO12: u32 = 531;
constant R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC (line 1800) | pub const R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC: u32 = 532;
constant R_AARCH64_TLSLD_LDST16_DTPREL_LO12 (line 1801) | pub const R_AARCH64_TLSLD_LDST16_DTPREL_LO12: u32 = 533;
constant R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC (line 1802) | pub const R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC: u32 = 534;
constant R_AARCH64_TLSLD_LDST32_DTPREL_LO12 (line 1803) | pub const R_AARCH64_TLSLD_LDST32_DTPREL_LO12: u32 = 535;
constant R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC (line 1804) | pub const R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC: u32 = 536;
constant R_AARCH64_TLSLD_LDST64_DTPREL_LO12 (line 1805) | pub const R_AARCH64_TLSLD_LDST64_DTPREL_LO12: u32 = 537;
constant R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC (line 1806) | pub const R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC: u32 = 538;
constant R_AARCH64_TLSIE_MOVW_GOTTPREL_G1 (line 1807) | pub const R_AARCH64_TLSIE_MOVW_GOTTPREL_G1: u32 = 539;
constant R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC (line 1808) | pub const R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC: u32 = 540;
constant R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 (line 1809) | pub const R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: u32 = 541;
constant R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC (line 1810) | pub const R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC: u32 = 542;
constant R_AARCH64_TLSIE_LD_GOTTPREL_PREL19 (line 1811) | pub const R_AARCH64_TLSIE_LD_GOTTPREL_PREL19: u32 = 543;
constant R_AARCH64_TLSLE_MOVW_TPREL_G2 (line 1812) | pub const R_AARCH64_TLSLE_MOVW_TPREL_G2: u32 = 544;
constant R_AARCH64_TLSLE_MOVW_TPREL_G1 (line 1813) | pub const R_AARCH64_TLSLE_MOVW_TPREL_G1: u32 = 545;
constant R_AARCH64_TLSLE_MOVW_TPREL_G1_NC (line 1814) | pub const R_AARCH64_TLSLE_MOVW_TPREL_G1_NC: u32 = 546;
constant R_AARCH64_TLSLE_MOVW_TPREL_G0 (line 1815) | pub const R_AARCH64_TLSLE_MOVW_TPREL_G0: u32 = 547;
constant R_AARCH64_TLSLE_MOVW_TPREL_G0_NC (line 1816) | pub const R_AARCH64_TLSLE_MOVW_TPREL_G0_NC: u32 = 548;
constant R_AARCH64_TLSLE_ADD_TPREL_HI12 (line 1817) | pub const R_AARCH64_TLSLE_ADD_TPREL_HI12: u32 = 549;
constant R_AARCH64_TLSLE_ADD_TPREL_LO12 (line 1818) | pub const R_AARCH64_TLSLE_ADD_TPREL_LO12: u32 = 550;
constant R_AARCH64_TLSLE_ADD_TPREL_LO12_NC (line 1819) | pub const R_AARCH64_TLSLE_ADD_TPREL_LO12_NC: u32 = 551;
constant R_AARCH64_TLSLE_LDST8_TPREL_LO12 (line 1820) | pub const R_AARCH64_TLSLE_LDST8_TPREL_LO12: u32 = 552;
constant R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC (line 1821) | pub const R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC: u32 = 553;
constant R_AARCH64_TLSLE_LDST16_TPREL_LO12 (line 1822) | pub const R_AARCH64_TLSLE_LDST16_TPREL_LO12: u32 = 554;
constant R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC (line 1823) | pub const R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC: u32 = 555;
constant R_AARCH64_TLSLE_LDST32_TPREL_LO12 (line 1824) | pub const R_AARCH64_TLSLE_LDST32_TPREL_LO12: u32 = 556;
constant R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC (line 1825) | pub const R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC: u32 = 557;
constant R_AARCH64_TLSLE_LDST64_TPREL_LO12 (line 1826) | pub const R_AARCH64_TLSLE_LDST64_TPREL_LO12: u32 = 558;
constant R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC (line 1827) | pub const R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC: u32 = 559;
constant R_AARCH64_TLSDESC_LD_PREL19 (line 1828) | pub const R_AARCH64_TLSDESC_LD_PREL19: u32 = 560;
constant R_AARCH64_TLSDESC_ADR_PREL21 (line 1829) | pub const R_AARCH64_TLSDESC_ADR_PREL21: u32 = 561;
constant R_AARCH64_TLSDESC_ADR_PAGE21 (line 1830) | pub const R_AARCH64_TLSDESC_ADR_PAGE21: u32 = 562;
constant R_AARCH64_TLSDESC_LD64_LO12 (line 1831) | pub const R_AARCH64_TLSDESC_LD64_LO12: u32 = 563;
constant R_AARCH64_TLSDESC_ADD_LO12 (line 1832) | pub const R_AARCH64_TLSDESC_ADD_LO12: u32 = 564;
constant R_AARCH64_TLSDESC_OFF_G1 (line 1833) | pub const R_AARCH64_TLSDESC_OFF_G1: u32 = 565;
constant R_AARCH64_TLSDESC_OFF_G0_NC (line 1834) | pub const R_AARCH64_TLSDESC_OFF_G0_NC: u32 = 566;
constant R_AARCH64_TLSDESC_LDR (line 1835) | pub const R_AARCH64_TLSDESC_LDR: u32 = 567;
constant R_AARCH64_TLSDESC_ADD (line 1836) | pub const R_AARCH64_TLSDESC_ADD: u32 = 568;
constant R_AARCH64_TLSDESC_CALL (line 1837) | pub const R_AARCH64_TLSDESC_CALL: u32 = 569;
constant R_AARCH64_TLSLE_LDST128_TPREL_LO12 (line 1838) | pub const R_AARCH64_TLSLE_LDST128_TPREL_LO12: u32 = 570;
constant R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC (line 1839) | pub const R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC: u32 = 571;
constant R_AARCH64_TLSLD_LDST128_DTPREL_LO12 (line 1840) | pub const R_AARCH64_TLSLD_LDST128_DTPREL_LO12: u32 = 572;
constant R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC (line 1841) | pub const R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC: u32 = 573;
constant R_AARCH64_COPY (line 1842) | pub const R_AARCH64_COPY: u32 = 1024;
constant R_AARCH64_GLOB_DAT (line 1843) | pub const R_AARCH64_GLOB_DAT: u32 = 1025;
constant R_AARCH64_JUMP_SLOT (line 1844) | pub const R_AARCH64_JUMP_SLOT: u32 = 1026;
constant R_AARCH64_RELATIVE (line 1845) | pub const R_AARCH64_RELATIVE: u32 = 1027;
constant R_AARCH64_TLS_DTPMOD (line 1846) | pub const R_AARCH64_TLS_DTPMOD: u32 = 1028;
constant R_AARCH64_TLS_DTPREL (line 1847) | pub const R_AARCH64_TLS_DTPREL: u32 = 1029;
constant R_AARCH64_TLS_TPREL (line 1848) | pub const R_AARCH64_TLS_TPREL: u32 = 1030;
constant R_AARCH64_TLSDESC (line 1849) | pub const R_AARCH64_TLSDESC: u32 = 1031;
constant R_AARCH64_IRELATIVE (line 1850) | pub const R_AARCH64_IRELATIVE: u32 = 1032;
constant R_ARM_NONE (line 1851) | pub const R_ARM_NONE: u32 = 0;
constant R_ARM_PC24 (line 1852) | pub const R_ARM_PC24: u32 = 1;
constant R_ARM_ABS32 (line 1853) | pub const R_ARM_ABS32: u32 = 2;
constant R_ARM_REL32 (line 1854) | pub const R_ARM_REL32: u32 = 3;
constant R_ARM_PC13 (line 1855) | pub const R_ARM_PC13: u32 = 4;
constant R_ARM_ABS16 (line 1856) | pub const R_ARM_ABS16: u32 = 5;
constant R_ARM_ABS12 (line 1857) | pub const R_ARM_ABS12: u32 = 6;
constant R_ARM_THM_ABS5 (line 1858) | pub const R_ARM_THM_ABS5: u32 = 7;
constant R_ARM_ABS8 (line 1859) | pub const R_ARM_ABS8: u32 = 8;
constant R_ARM_SBREL32 (line 1860) | pub const R_ARM_SBREL32: u32 = 9;
constant R_ARM_THM_PC22 (line 1861) | pub const R_ARM_THM_PC22: u32 = 10;
constant R_ARM_THM_PC8 (line 1862) | pub const R_ARM_THM_PC8: u32 = 11;
constant R_ARM_AMP_VCALL9 (line 1863) | pub const R_ARM_AMP_VCALL9: u32 = 12;
constant R_ARM_SWI24 (line 1864) | pub const R_ARM_SWI24: u32 = 13;
constant R_ARM_TLS_DESC (line 1865) | pub const R_ARM_TLS_DESC: u32 = 13;
constant R_ARM_THM_SWI8 (line 1866) | pub const R_ARM_THM_SWI8: u32 = 14;
constant R_ARM_XPC25 (line 1867) | pub const R_ARM_XPC25: u32 = 15;
constant R_ARM_THM_XPC22 (line 1868) | pub const R_ARM_THM_XPC22: u32 = 16;
constant R_ARM_TLS_DTPMOD32 (line 1869) | pub const R_ARM_TLS_DTPMOD32: u32 = 17;
constant R_ARM_TLS_DTPOFF32 (line 1870) | pub const R_ARM_TLS_DTPOFF32: u32 = 18;
constant R_ARM_TLS_TPOFF32 (line 1871) | pub const R_ARM_TLS_TPOFF32: u32 = 19;
constant R_ARM_COPY (line 1872) | pub const R_ARM_COPY: u32 = 20;
constant R_ARM_GLOB_DAT (line 1873) | pub const R_ARM_GLOB_DAT: u32 = 21;
constant R_ARM_JUMP_SLOT (line 1874) | pub const R_ARM_JUMP_SLOT: u32 = 22;
constant R_ARM_RELATIVE (line 1875) | pub const R_ARM_RELATIVE: u32 = 23;
constant R_ARM_GOTOFF (line 1876) | pub const R_ARM_GOTOFF: u32 = 24;
constant R_ARM_GOTPC (line 1877) | pub const R_ARM_GOTPC: u32 = 25;
constant R_ARM_GOT32 (line 1878) | pub const R_ARM_GOT32: u32 = 26;
constant R_ARM_PLT32 (line 1879) | pub const R_ARM_PLT32: u32 = 27;
constant R_ARM_CALL (line 1880) | pub const R_ARM_CALL: u32 = 28;
constant R_ARM_JUMP24 (line 1881) | pub const R_ARM_JUMP24: u32 = 29;
constant R_ARM_THM_JUMP24 (line 1882) | pub const R_ARM_THM_JUMP24: u32 = 30;
constant R_ARM_BASE_ABS (line 1883) | pub const R_ARM_BASE_ABS: u32 = 31;
constant R_ARM_ALU_PCREL_7_0 (line 1884) | pub const R_ARM_ALU_PCREL_7_0: u32 = 32;
constant R_ARM_ALU_PCREL_15_8 (line 1885) | pub const R_ARM_ALU_PCREL_15_8: u32 = 33;
constant R_ARM_ALU_PCREL_23_15 (line 1886) | pub const R_ARM_ALU_PCREL_23_15: u32 = 34;
constant R_ARM_LDR_SBREL_11_0 (line 1887) | pub const R_ARM_LDR_SBREL_11_0: u32 = 35;
constant R_ARM_ALU_SBREL_19_12 (line 1888) | pub const R_ARM_ALU_SBREL_19_12: u32 = 36;
constant R_ARM_ALU_SBREL_27_20 (line 1889) | pub const R_ARM_ALU_SBREL_27_20: u32 = 37;
constant R_ARM_TARGET1 (line 1890) | pub const R_ARM_TARGET1: u32 = 38;
constant R_ARM_SBREL31 (line 1891) | pub const R_ARM_SBREL31: u32 = 39;
constant R_ARM_V4BX (line 1892) | pub const R_ARM_V4BX: u32 = 40;
constant R_ARM_TARGET2 (line 1893) | pub const R_ARM_TARGET2: u32 = 41;
constant R_ARM_PREL31 (line 1894) | pub const R_ARM_PREL31: u32 = 42;
constant R_ARM_MOVW_ABS_NC (line 1895) | pub const R_ARM_MOVW_ABS_NC: u32 = 43;
constant R_ARM_MOVT_ABS (line 1896) | pub const R_ARM_MOVT_ABS: u32 = 44;
constant R_ARM_MOVW_PREL_NC (line 1897) | pub const R_ARM_MOVW_PREL_NC: u32 = 45;
constant R_ARM_MOVT_PREL (line 1898) | pub const R_ARM_MOVT_PREL: u32 = 46;
constant R_ARM_THM_MOVW_ABS_NC (line 1899) | pub const R_ARM_THM_MOVW_ABS_NC: u32 = 47;
constant R_ARM_THM_MOVT_ABS (line 1900) | pub const R_ARM_THM_MOVT_ABS: u32 = 48;
constant R_ARM_THM_MOVW_PREL_NC (line 1901) | pub const R_ARM_THM_MOVW_PREL_NC: u32 = 49;
constant R_ARM_THM_MOVT_PREL (line 1902) | pub const R_ARM_THM_MOVT_PREL: u32 = 50;
constant R_ARM_THM_JUMP19 (line 1903) | pub const R_ARM_THM_JUMP19: u32 = 51;
constant R_ARM_THM_JUMP6 (line 1904) | pub const R_ARM_THM_JUMP6: u32 = 52;
constant R_ARM_THM_ALU_PREL_11_0 (line 1905) | pub const R_ARM_THM_ALU_PREL_11_0: u32 = 53;
constant R_ARM_THM_PC12 (line 1906) | pub const R_ARM_THM_PC12: u32 = 54;
constant R_ARM_ABS32_NOI (line 1907) | pub const R_ARM_ABS32_NOI: u32 = 55;
constant R_ARM_REL32_NOI (line 1908) | pub const R_ARM_REL32_NOI: u32 = 56;
constant R_ARM_ALU_PC_G0_NC (line 1909) | pub const R_ARM_ALU_PC_G0_NC: u32 = 57;
constant R_ARM_ALU_PC_G0 (line 1910) | pub const R_ARM_ALU_PC_G0: u32 = 58;
constant R_ARM_ALU_PC_G1_NC (line 1911) | pub const R_ARM_ALU_PC_G1_NC: u32 = 59;
constant R_ARM_ALU_PC_G1 (line 1912) | pub const R_ARM_ALU_PC_G1: u32 = 60;
constant R_ARM_ALU_PC_G2 (line 1913) | pub const R_ARM_ALU_PC_G2: u32 = 61;
constant R_ARM_LDR_PC_G1 (line 1914) | pub const R_ARM_LDR_PC_G1: u32 = 62;
constant R_ARM_LDR_PC_G2 (line 1915) | pub const R_ARM_LDR_PC_G2: u32 = 63;
constant R_ARM_LDRS_PC_G0 (line 1916) | pub const R_ARM_LDRS_PC_G0: u32 = 64;
constant R_ARM_LDRS_PC_G1 (line 1917) | pub const R_ARM_LDRS_PC_G1: u32 = 65;
constant R_ARM_LDRS_PC_G2 (line 1918) | pub const R_ARM_LDRS_PC_G2: u32 = 66;
constant R_ARM_LDC_PC_G0 (line 1919) | pub const R_ARM_LDC_PC_G0: u32 = 67;
constant R_ARM_LDC_PC_G1 (line 1920) | pub const R_ARM_LDC_PC_G1: u32 = 68;
constant R_ARM_LDC_PC_G2 (line 1921) | pub const R_ARM_LDC_PC_G2: u32 = 69;
constant R_ARM_ALU_SB_G0_NC (line 1922) | pub const R_ARM_ALU_SB_G0_NC: u32 = 70;
constant R_ARM_ALU_SB_G0 (line 1923) | pub const R_ARM_ALU_SB_G0: u32 = 71;
constant R_ARM_ALU_SB_G1_NC (line 1924) | pub const R_ARM_ALU_SB_G1_NC: u32 = 72;
constant R_ARM_ALU_SB_G1 (line 1925) | pub const R_ARM_ALU_SB_G1: u32 = 73;
constant R_ARM_ALU_SB_G2 (line 1926) | pub const R_ARM_ALU_SB_G2: u32 = 74;
constant R_ARM_LDR_SB_G0 (line 1927) | pub const R_ARM_LDR_SB_G0: u32 = 75;
constant R_ARM_LDR_SB_G1 (line 1928) | pub const R_ARM_LDR_SB_G1: u32 = 76;
constant R_ARM_LDR_SB_G2 (line 1929) | pub const R_ARM_LDR_SB_G2: u32 = 77;
constant R_ARM_LDRS_SB_G0 (line 1930) | pub const R_ARM_LDRS_SB_G0: u32 = 78;
constant R_ARM_LDRS_SB_G1 (line 1931) | pub const R_ARM_LDRS_SB_G1: u32 = 79;
constant R_ARM_LDRS_SB_G2 (line 1932) | pub const R_ARM_LDRS_SB_G2: u32 = 80;
constant R_ARM_LDC_SB_G0 (line 1933) | pub const R_ARM_LDC_SB_G0: u32 = 81;
constant R_ARM_LDC_SB_G1 (line 1934) | pub const R_ARM_LDC_SB_G1: u32 = 82;
constant R_ARM_LDC_SB_G2 (line 1935) | pub const R_ARM_LDC_SB_G2: u32 = 83;
constant R_ARM_MOVW_BREL_NC (line 1936) | pub const R_ARM_MOVW_BREL_NC: u32 = 84;
constant R_ARM_MOVT_BREL (line 1937) | pub const R_ARM_MOVT_BREL: u32 = 85;
constant R_ARM_MOVW_BREL (line 1938) | pub const R_ARM_MOVW_BREL: u32 = 86;
constant R_ARM_THM_MOVW_BREL_NC (line 1939) | pub const R_ARM_THM_MOVW_BREL_NC: u32 = 87;
constant R_ARM_THM_MOVT_BREL (line 1940) | pub const R_ARM_THM_MOVT_BREL: u32 = 88;
constant R_ARM_THM_MOVW_BREL (line 1941) | pub const R_ARM_THM_MOVW_BREL: u32 = 89;
constant R_ARM_TLS_GOTDESC (line 1942) | pub const R_ARM_TLS_GOTDESC: u32 = 90;
constant R_ARM_TLS_CALL (line 1943) | pub const R_ARM_TLS_CALL: u32 = 91;
constant R_ARM_TLS_DESCSEQ (line 1944) | pub const R_ARM_TLS_DESCSEQ: u32 = 92;
constant R_ARM_THM_TLS_CALL (line 1945) | pub const R_ARM_THM_TLS_CALL: u32 = 93;
constant R_ARM_PLT32_ABS (line 1946) | pub const R_ARM_PLT32_ABS: u32 = 94;
constant R_ARM_GOT_ABS (line 1947) | pub const R_ARM_GOT_ABS: u32 = 95;
constant R_ARM_GOT_PREL (line 1948) | pub const R_ARM_GOT_PREL: u32 = 96;
constant R_ARM_GOT_BREL12 (line 1949) | pub const R_ARM_GOT_BREL12: u32 = 97;
constant R_ARM_GOTOFF12 (line 1950) | pub const R_ARM_GOTOFF12: u32 = 98;
constant R_ARM_GOTRELAX (line 1951) | pub const R_ARM_GOTRELA
Copy disabled (too large)
Download .json
Condensed preview — 1466 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (10,940K chars).
[
{
"path": ".cirrus.yml",
"chars": 1039,
"preview": "freebsd_instance:\n image: freebsd-12-0-release-amd64\n\ntask:\n name: FreeBSD 12.0 amd64\n setup_script:\n - pkg instal"
},
{
"path": ".gitignore",
"chars": 350,
"preview": "# Generated by Cargo\n# will have compiled files and executables\ntarget/\n\n# Remove Cargo.lock from gitignore if creating "
},
{
"path": ".gitmodules",
"chars": 262,
"preview": "[submodule \"libstapsdt-sys/vendor/libstapsdt\"]\n\tpath = tracers-libstapsdt-sys/vendor/libstapsdt\n\turl = https://github.co"
},
{
"path": ".tmuxp.yaml",
"chars": 266,
"preview": "session_name: tracers\nstart_directory: ./\nwindows:\n - window_name: editor\n focus: true\n panes:\n - "
},
{
"path": "Cargo.toml",
"chars": 396,
"preview": "[workspace]\nmembers = [\n \"tracers-libelf-sys\",\n \"tracers-libstapsdt-sys\",\n \"tracers-build\",\n \"tracers-codege"
},
{
"path": "LICENSE",
"chars": 261,
"preview": "This project is licensed under either of\n\n * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or\n http:/"
},
{
"path": "LICENSE-APACHE",
"chars": 10831,
"preview": " Apache License\n Version 2.0, January 2004\n http"
},
{
"path": "LICENSE-MIT",
"chars": 1055,
"preview": "Copyright (c) 2019 Adam Nelson\n\nPermission is hereby granted, free of charge, to any\nperson obtaining a copy of this sof"
},
{
"path": "README.md",
"chars": 6155,
"preview": "# tracers - Rust instrumentation library\n\n[](https://"
},
{
"path": "azure-pipelines.yml",
"chars": 8244,
"preview": "# This pipeline stolen shamelessly from https://github.com/nickbabcock/rrinlog\ntrigger:\n branches:\n include: ['*']\n "
},
{
"path": "bin/pre-publish.sh",
"chars": 591,
"preview": "#!/usr/bin/env bash\n#\n# Does a dry run on publishing all crates to check for problems\nset -e\nSCRIPTPATH=\"$( cd \"$(dirnam"
},
{
"path": "bin/publish.sh",
"chars": 2664,
"preview": "#!/usr/bin/env bash\n#\n# Borrowed quite shamelessly from https://github.com/tracers-rs/tracing/blob/master/bin/publish\n\ns"
},
{
"path": "examples/simple/Cargo.toml",
"chars": 354,
"preview": "[package]\nname = \"simple\"\nversion = \"0.2.0\"\nauthors = [\"Adam Nelson <anelson@users.noreply.github.com>\"]\nedition = \"2018"
},
{
"path": "examples/simple/build.rs",
"chars": 54,
"preview": "use tracers_build::build;\n\nfn main() {\n build();\n}\n"
},
{
"path": "examples/simple/src/main.rs",
"chars": 689,
"preview": "//! This is a simple binary which declares and fires some simple probes\n//!\n//! It's the \"hello world\" equivalent for tr"
},
{
"path": "scripts/build.bat",
"chars": 27,
"preview": "@ ECHO OFF\n\ncargo build %*\n"
},
{
"path": "scripts/build.sh",
"chars": 103,
"preview": "#!/usr/bin/env bash\n#\n# Builds the project on UNIX-like systems\nset -u\nset -e\n\ncargo build \\\n \"$@\"\n\n"
},
{
"path": "scripts/test.bat",
"chars": 27,
"preview": "@ ECHO OFF\n\ncargo test %*\n"
},
{
"path": "scripts/test.sh",
"chars": 102,
"preview": "#!/usr/bin/env bash\n#\n# Builds the project on UNIX-like systems\nset -u\nset -e\n\ncargo test \\\n \"$@\"\n\n"
},
{
"path": "tracers/Cargo.toml",
"chars": 3414,
"preview": "[package]\nname = \"tracers\"\nversion = \"0.2.0\"\nauthors = [\"Adam Nelson <anelson@127.io>\"]\nedition = \"2018\"\nlicense = \"MIT "
},
{
"path": "tracers/benches/probe_firing.rs",
"chars": 11246,
"preview": "#![deny(warnings)]\nuse criterion::{black_box, criterion_group, criterion_main, Bencher, Criterion, Fun};\n#[allow(unused_"
},
{
"path": "tracers/build.rs",
"chars": 189,
"preview": "//! Custom build logic that uses the features enabled by the dependent crate to determine which\n//! tracing implementati"
},
{
"path": "tracers/examples/simple.rs",
"chars": 348,
"preview": "#![deny(warnings)]\n\nuse tracers_macros::probe;\nuse tracers_macros::tracer;\n\n#[tracer]\ntrait SimpleTestProbes {\n fn pr"
},
{
"path": "tracers/examples/submodules.rs",
"chars": 1179,
"preview": "//! it's also possible to declare a provider struct in one module and fire the probes from another.\n//! the only require"
},
{
"path": "tracers/src/bin/profile_target.rs",
"chars": 1147,
"preview": "//! This very simple binary is used for profiling the tracing system itself to experiment with\n//! various optimizations"
},
{
"path": "tracers/src/bin/stap_probes.d",
"chars": 42,
"preview": "provider staptest {\n probe probe0();\n}\n"
},
{
"path": "tracers/src/bin/stap_probes.h",
"chars": 609,
"preview": "/* Generated by the Systemtap dtrace wrapper */\n\n\n#define _SDT_HAS_SEMAPHORES 1\n\n\n#define STAP_HAS_SEMAPHORES 1 /* depre"
},
{
"path": "tracers/src/bin/stap_probes.o.dtrace-temp.c",
"chars": 578,
"preview": "/* Generated by the Systemtap dtrace wrapper */\n\nstatic void __dtrace (void) __attribute__((unused));\nstatic void __dtra"
},
{
"path": "tracers/src/bin/testfire.rs",
"chars": 3210,
"preview": "use nom::*;\nuse std::io::prelude::*;\nuse tracers_macros::{init_provider, probe, tracer};\n\n/// This is a probe provider w"
},
{
"path": "tracers/src/lib.rs",
"chars": 3543,
"preview": "#![deny(warnings)]\n\n/// The code generated by `tracers-macros` will at runtime require some functionality, both from\n///"
},
{
"path": "tracers/tests/custom_provider_names.rs",
"chars": 1046,
"preview": "//! The default provider name is derived from the trait's name. But this name is used to make the\n//! names of the nati"
},
{
"path": "tracers/tests/simple.rs",
"chars": 1049,
"preview": "#![deny(warnings)]\n#![allow(clippy::blacklisted_name)] //\"foo\"\nuse tracers_macros::{init_provider, probe, tracer};\n\n#[tr"
},
{
"path": "tracers-build/Cargo.toml",
"chars": 530,
"preview": "[package]\nname = \"tracers-build\"\nversion = \"0.2.0\"\nauthors = [\"Adam Nelson <anelson@127.io>\"]\nedition = \"2018\"\nlicense ="
},
{
"path": "tracers-build/src/lib.rs",
"chars": 177,
"preview": "//! Simply re-exports the build-related functions in `tracers-codegen`\n\npub use tracers_codegen::{build, tracers_build};"
},
{
"path": "tracers-codegen/Cargo.toml",
"chars": 1311,
"preview": "[package]\nname = \"tracers-codegen\"\nversion = \"0.2.0\"\nauthors = [\"Adam Nelson <anelson@127.io>\"]\nedition = \"2018\"\nlicense"
},
{
"path": "tracers-codegen/src/argtypes.rs",
"chars": 11798,
"preview": "//! Almost all of the probing code takes advantage of Rust's type system to ensure any type passed\n//! to a probe can be"
},
{
"path": "tracers-codegen/src/build_rs.rs",
"chars": 27849,
"preview": "//! This module contains the code that is used within `tracers`s build.rs` file to select\n//! the suitable tracing imple"
},
{
"path": "tracers-codegen/src/cache.rs",
"chars": 13888,
"preview": "//! Implements a simple filesystem-based caching system, where the results of idempotent\n//! computations on either file"
},
{
"path": "tracers-codegen/src/cargo.rs",
"chars": 1686,
"preview": "use cargo_metadata::MetadataCommand;\nuse failure::{format_err, Fallible};\nuse std::path::Path;\nuse std::path::PathBuf;\n\n"
},
{
"path": "tracers-codegen/src/deps.rs",
"chars": 7786,
"preview": "//! This module contains logic that looks into the AST of a Rust source file and finds dependent\n//! source files. By \""
},
{
"path": "tracers-codegen/src/error.rs",
"chars": 11797,
"preview": "//! Defines an error type which can represent all the various kinds of failures the code gen\n//! process can encounter. "
},
{
"path": "tracers-codegen/src/gen/common/mod.rs",
"chars": 12859,
"preview": "//! This module contains some code which is shared between the different code generation\n//! implementations. It does n"
},
{
"path": "tracers-codegen/src/gen/dynamic/mod.rs",
"chars": 2445,
"preview": "//! The `dynamic` generator generates probing code which uses the runtime tracing API in\n//! `tracers-core`. Currently "
},
{
"path": "tracers-codegen/src/gen/dynamic/probe_call.rs",
"chars": 2831,
"preview": "//! This module generates the code for a call to a probe implemented with the `libstapsdt` library.\n//! It's rather simp"
},
{
"path": "tracers-codegen/src/gen/dynamic/provider_trait.rs",
"chars": 27045,
"preview": "//!Code in this module processes the provider trait decorated with the `tracers` attribute, and\n//!replaces it with an i"
},
{
"path": "tracers-codegen/src/gen/mod.rs",
"chars": 4860,
"preview": "//! This is the main module for all code generators, both the build-time generators invoked from\n//! `build.rs` and the "
},
{
"path": "tracers-codegen/src/gen/static/c.rs",
"chars": 3942,
"preview": "//! Generates C code which implements each probe in terms of the target platform's tracing system,\n//! if there is one.\n"
},
{
"path": "tracers-codegen/src/gen/static/mod.rs",
"chars": 3237,
"preview": "//! This module contains the code to support the static style of probing, which is more like the\n//! static C support fo"
},
{
"path": "tracers-codegen/src/gen/static/native_code/.gitignore",
"chars": 80,
"preview": "# In this particular case the `target` directory contains source code\n!target/\n\n"
},
{
"path": "tracers-codegen/src/gen/static/native_code/mod.rs",
"chars": 16720,
"preview": "//! This module is responsible for generating the native C wrappers for each provider, which thunk\n//! calls to the targ"
},
{
"path": "tracers-codegen/src/gen/static/native_code/target/lttng.rs",
"chars": 13963,
"preview": "//! Contains the native C++ code generator and the Rust bindings generator to support Linux\n//! SystemTap user-mode trac"
},
{
"path": "tracers-codegen/src/gen/static/native_code/target/mod.rs",
"chars": 209,
"preview": "//! Contains one sub-module for every supported tracing target. Each one contains an\n//! implementation of `NativeCodeG"
},
{
"path": "tracers-codegen/src/gen/static/native_code/target/stap.rs",
"chars": 3713,
"preview": "//! Contains the native C++ code generator and the Rust bindings generator to support Linux\n//! SystemTap user-mode trac"
},
{
"path": "tracers-codegen/src/gen/static/probe_call.rs",
"chars": 6964,
"preview": "//! This generates probe calls for the `probe!` macro when the no-op implementation is being used.\n//! That means the ca"
},
{
"path": "tracers-codegen/src/gen/static/provider_trait.rs",
"chars": 32853,
"preview": "//! This module contains the code that transforms a trait with the `tracer` attribute into the\n//! infrastructure to per"
},
{
"path": "tracers-codegen/src/hashing.rs",
"chars": 2368,
"preview": "//! This module provides a fast but not cryptographically secure hashing algorithm and helper\n//! functions which are us"
},
{
"path": "tracers-codegen/src/lib.rs",
"chars": 3298,
"preview": "#![deny(warnings)]\n#![recursion_limit = \"512\"]\n\nuse serde::{Deserialize, Serialize};\nuse std::str::FromStr;\nuse strum::E"
},
{
"path": "tracers-codegen/src/proc_macros.rs",
"chars": 2871,
"preview": "//! This module is where the *implementation* of the probe-related proc macros are. The actual\n//! proc macro is in the"
},
{
"path": "tracers-codegen/src/serde_helpers.rs",
"chars": 3368,
"preview": "//! This module contains some internal helpers to provide field-expedient ser/deser of some types\n//! that do not and ca"
},
{
"path": "tracers-codegen/src/spec/init_provider.rs",
"chars": 2125,
"preview": "//! This module parses the tokens passed to the `init_provider!` macro, validates them, and\n//! represents the tokens in"
},
{
"path": "tracers-codegen/src/spec/mod.rs",
"chars": 1439,
"preview": "//! This module and its sub-modules contain structures which represent the parsed and processed\n//! contents of the vari"
},
{
"path": "tracers-codegen/src/spec/probe.rs",
"chars": 10723,
"preview": "//! This module.res and implements the `ProbeSpecification` struct, which represents a single\n//! tracing probe correspo"
},
{
"path": "tracers-codegen/src/spec/probe_arg.rs",
"chars": 12853,
"preview": "//! This module is concerned with parsing and interpreting the arguments to a probe\n\nuse crate::argtypes;\nuse crate::arg"
},
{
"path": "tracers-codegen/src/spec/probe_call.rs",
"chars": 7219,
"preview": "//! This module handles parsing calls to a probe made using the `probe!` proc macro, decomposing\n//! them into the discr"
},
{
"path": "tracers-codegen/src/spec/provider.rs",
"chars": 22376,
"preview": "//! This module provides functionality to scan the AST of a Rust source file and identify\n//! `tracers` provider traits "
},
{
"path": "tracers-codegen/src/syn_helpers.rs",
"chars": 8813,
"preview": "//! This module contains some helpers for working with the `syn` crate. They grew to be\n//! sufficiently complex as to "
},
{
"path": "tracers-codegen/src/testdata.rs",
"chars": 26689,
"preview": "//! This module contains some shared code and structures for dealing with the test data in the\n//! `testdata/` directory"
},
{
"path": "tracers-codegen/templates/lttng/provider.tp",
"chars": 819,
"preview": "/** This file automatically generated by {{env!(\"CARGO_PKG_NAME\")}} {{env!(\"CARGO_PKG_VERSION\")}}. Do not edit\n * this "
},
{
"path": "tracers-codegen/templates/lttng/provider_wrapper.cpp",
"chars": 1387,
"preview": "/** This file automatically generated by {{env!(\"CARGO_PKG_NAME\")}} {{env!(\"CARGO_PKG_VERSION\")}}. Do not edit\n * this "
},
{
"path": "tracers-codegen/templates/stap/provider_wrapper.cpp",
"chars": 1349,
"preview": "/** This file automatically generated by {{env!(\"CARGO_PKG_NAME\")}} {{env!(\"CARGO_PKG_VERSION\")}}. Do not edit\n * this "
},
{
"path": "tracers-codegen/templates/stap/sys_sdt.h",
"chars": 18878,
"preview": "/* <sys/sdt.h> - Systemtap static probe definition macros.\n\n This file is dedicated to the public domain, pursuant to "
},
{
"path": "tracers-codegen/testdata/complexlib/Cargo.toml",
"chars": 367,
"preview": "[package]\nname = \"complexlib\"\nversion = \"0.1.0\"\nauthors = [\"Adam Nelson <anelson@users.noreply.github.com>\"]\nedition = \""
},
{
"path": "tracers-codegen/testdata/complexlib/build.rs",
"chars": 41,
"preview": "fn main() {\n tracers_build::build()\n}\n"
},
{
"path": "tracers-codegen/testdata/complexlib/examples/ex1.rs",
"chars": 0,
"preview": ""
},
{
"path": "tracers-codegen/testdata/complexlib/src/bin/bin1.rs",
"chars": 175,
"preview": "use complexlib::VariousProbes;\nuse tracers_macros::probe;\n\nfn main() {\n probe!(VariousProbes::bin1_start());\n prin"
},
{
"path": "tracers-codegen/testdata/complexlib/src/bin/bin2.rs",
"chars": 175,
"preview": "use complexlib::VariousProbes;\nuse tracers_macros::probe;\n\nfn main() {\n probe!(VariousProbes::bin2_start());\n prin"
},
{
"path": "tracers-codegen/testdata/complexlib/src/lib.rs",
"chars": 244,
"preview": "use tracers_macros::tracer;\n\n#[tracer]\npub trait VariousProbes {\n fn bin1_start();\n fn bin1_end();\n\n fn bin2_st"
},
{
"path": "tracers-codegen/testdata/complexlib/tests/static/mod.rs",
"chars": 142,
"preview": "//! This module is called `static` which is a Rust reserved word, so resolving it should be a good\n//! test of our depen"
},
{
"path": "tracers-codegen/testdata/complexlib/tests/test1.rs",
"chars": 14,
"preview": "mod r#static;\n"
},
{
"path": "tracers-codegen/testdata/complexlib/tests/test2.rs",
"chars": 0,
"preview": ""
},
{
"path": "tracers-codegen/testdata/errors/Cargo.toml",
"chars": 141,
"preview": "[package]\nname = \"erroneous\"\nversion = \"0.1.0\"\nauthors = [\"Adam Nelson <anelson@users.noreply.github.com>\"]\nedition = \"2"
},
{
"path": "tracers-codegen/testdata/errors/src/child_mod/grandchild_mod.rs",
"chars": 90,
"preview": "//This module doesn't exist; we're testing an error case here\nmod this_mod_doesnt_exist;\n\n"
},
{
"path": "tracers-codegen/testdata/errors/src/child_mod/mod.rs",
"chars": 21,
"preview": "mod grandchild_mod;\n\n"
},
{
"path": "tracers-codegen/testdata/errors/src/main.rs",
"chars": 61,
"preview": "mod child_mod;\n\nfn main() {\n println!(\"Hello, world!\");\n}\n"
},
{
"path": "tracers-codegen/testdata/errors/tests/compile_errors.rs",
"chars": 48,
"preview": "mod with_errors;\n\nfn foo() { unimplemented!() }\n"
},
{
"path": "tracers-codegen/testdata/errors/tests/with_errors/mod.rs",
"chars": 92,
"preview": "This isn't even valid Rust code!\n\nNo way it will compile.\n\nBut it's at least valid Perl...\n\n"
},
{
"path": "tracers-codegen/testdata/simplebin/Cargo.toml",
"chars": 141,
"preview": "[package]\nname = \"simplebin\"\nversion = \"0.1.0\"\nauthors = [\"Adam Nelson <anelson@users.noreply.github.com>\"]\nedition = \"2"
},
{
"path": "tracers-codegen/testdata/simplebin/src/child_module.rs",
"chars": 22,
"preview": "pub fn something() {}\n"
},
{
"path": "tracers-codegen/testdata/simplebin/src/main.rs",
"chars": 95,
"preview": "mod child_module;\n\nfn main() {\n child_module::something();\n println!(\"Hello, world!\");\n}\n"
},
{
"path": "tracers-codegen/testdata/simplelib/Cargo.toml",
"chars": 366,
"preview": "[package]\nname = \"simplelib\"\nversion = \"0.1.0\"\nauthors = [\"Adam Nelson <anelson@users.noreply.github.com>\"]\nedition = \"2"
},
{
"path": "tracers-codegen/testdata/simplelib/build.rs",
"chars": 42,
"preview": "fn main() {\n tracers_build::build();\n}\n"
},
{
"path": "tracers-codegen/testdata/simplelib/src/child_module.rs",
"chars": 234,
"preview": "use tracers_macros::{tracer, probe};\n\n#[tracer]\npub(super) trait MyTraceProvider {\n fn something_happend();\n\n fn s"
},
{
"path": "tracers-codegen/testdata/simplelib/src/lib.rs",
"chars": 243,
"preview": "use tracers_macros::probe;\npub mod child_module;\n\npub fn something_else() {\n probe!(child_module::MyTraceProvider::so"
},
{
"path": "tracers-core/Cargo.toml",
"chars": 820,
"preview": "[package]\nname = \"tracers-core\"\nversion = \"0.2.0\"\nauthors = [\"Adam Nelson <anelson@127.io>\"]\nedition = \"2018\"\nlicense = "
},
{
"path": "tracers-core/build.rs",
"chars": 18921,
"preview": "//! Custom build script to programmatically generate support for tuples of up to 12 probe arguments.\n//!\n//! This may be"
},
{
"path": "tracers-core/src/argtypes/bool.rs",
"chars": 514,
"preview": "use super::{ProbeArgType, ProbeArgWrapper};\n\nimpl ProbeArgType<bool> for bool {\n type WrapperType = bool;\n fn wrap"
},
{
"path": "tracers-core/src/argtypes/cstring.rs",
"chars": 1722,
"preview": "//! This module provides an implementation of the arg type plumbing which passes a rust `CString` to a native C function"
},
{
"path": "tracers-core/src/argtypes/int.rs",
"chars": 1830,
"preview": "use super::{ProbeArgType, ProbeArgWrapper};\n\n#[cfg(test)]\nextern crate quickcheck;\n\n// Using the macro to avoid duplicat"
},
{
"path": "tracers-core/src/argtypes/native.rs",
"chars": 1979,
"preview": "//! This module implements the marker trait `ProbeArgNativeType` for those Rust types that correspond directly to C type"
},
{
"path": "tracers-core/src/argtypes/option.rs",
"chars": 3310,
"preview": "//! This module implements `ProbeArgType` and `ProbeArgWrapper` for `Option<T>` for any `T`\n//! whichwould itself be a v"
},
{
"path": "tracers-core/src/argtypes/pointer.rs",
"chars": 958,
"preview": "use super::{ProbeArgType, ProbeArgWrapper};\nuse std::os::raw;\n\nimpl<T> ProbeArgType<*const T> for *const T {\n type Wr"
},
{
"path": "tracers-core/src/argtypes/refs.rs",
"chars": 1044,
"preview": "//! This module ensures that if `ProbeArgType` and `ProbeArgWrapper` are implemented for some `T`, then they are also im"
},
{
"path": "tracers-core/src/argtypes/string.rs",
"chars": 5846,
"preview": "//! This module implements ProbeArgType and ProbeArgWrapper for Rust's string types. This\n//! implementation will be av"
},
{
"path": "tracers-core/src/argtypes.rs",
"chars": 4929,
"preview": "//! This module and its submodules implement a type-safe wrapper around Rust types such that any\n//! suitable type can b"
},
{
"path": "tracers-core/src/dynamic.rs",
"chars": 8866,
"preview": "//! This module contains the dynamic tracing API which is implemented by various platform-specific\n//! providers.\n//!\n//"
},
{
"path": "tracers-core/src/lib.rs",
"chars": 910,
"preview": "#![deny(warnings)]\n\n#[cfg(test)]\n#[macro_use(quickcheck)]\nextern crate quickcheck_macros;\n\n//Re-export some third-party "
},
{
"path": "tracers-dyn-noop/Cargo.toml",
"chars": 685,
"preview": "[package]\nname = \"tracers-dyn-noop\"\nversion = \"0.2.0\"\nauthors = [\"Adam Nelson <anelson@127.io>\"]\nedition = \"2018\"\nlicens"
},
{
"path": "tracers-dyn-noop/build.rs",
"chars": 2314,
"preview": "//! Custom build logic that auto generates the UnsafeProviderProbeNativeImpl that does nothing,\n//! since this is the 'n"
},
{
"path": "tracers-dyn-noop/src/lib.rs",
"chars": 128,
"preview": "#![deny(warnings)]\n\npub mod probe;\npub mod provider;\npub mod tracer;\n\npub use probe::*;\npub use provider::*;\npub use tra"
},
{
"path": "tracers-dyn-noop/src/probe.rs",
"chars": 585,
"preview": "//! Implements the `UnsafeProviderProbeImpl` trait that does nothing ('no-op')\n\nuse tracers_core::{dynamic::UnsafeProvid"
},
{
"path": "tracers-dyn-noop/src/provider.rs",
"chars": 1030,
"preview": "//! Implements the `ProviderBuilder` and `Provider` traits for SystemTap\nuse failure::Fallible;\nuse tracers_core::dynami"
},
{
"path": "tracers-dyn-noop/src/tracer.rs",
"chars": 925,
"preview": "//! This module implements the `Tracer` trait in such a way that the API calls all work but don't\n//! do anything. In r"
},
{
"path": "tracers-dyn-stap/Cargo.toml",
"chars": 2167,
"preview": "[package]\nname = \"tracers-dyn-stap\"\nversion = \"0.2.0\"\nauthors = [\"Adam Nelson <anelson@127.io>\"]\nedition = \"2018\"\nlicens"
},
{
"path": "tracers-dyn-stap/build.rs",
"chars": 5086,
"preview": "//! Custom build logic that auto generates the UnsafeProviderProbeNativeImpl for SystemTap, one method for\n//! each poss"
},
{
"path": "tracers-dyn-stap/src/lib.rs",
"chars": 286,
"preview": "#![deny(warnings)]\n\n//Only include any of this if stap is enabled for this build\n\n#[cfg(enabled)]\npub mod probe;\n#[cfg(e"
},
{
"path": "tracers-dyn-stap/src/probe.rs",
"chars": 1219,
"preview": "//! Implements the `UnsafeProviderProbeImpl` trait for SystemTap\n\nuse tracers_libstapsdt_sys::{probeFire, SDTProbe_t};\nu"
},
{
"path": "tracers-dyn-stap/src/provider.rs",
"chars": 8655,
"preview": "//! Implements the `ProviderBuilder` and `Provider` traits for SystemTap\nuse failure::{Fail, Fallible};\nuse tracers_libs"
},
{
"path": "tracers-dyn-stap/src/tracer.rs",
"chars": 927,
"preview": "//! This module implements the `Tracer` trait in terms of the `libstapsdt-sys` crate; that is,\n//! it implements `Tracer"
},
{
"path": "tracers-libelf-sys/COPYING-LGPLV3",
"chars": 7651,
"preview": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007"
},
{
"path": "tracers-libelf-sys/Cargo.toml",
"chars": 1214,
"preview": "[package]\nname = \"tracers-libelf-sys\"\nversion = \"0.2.0\"\nauthors = [\"Adam Nelson <anelson@127.io>\"]\nedition = \"2018\"\nlice"
},
{
"path": "tracers-libelf-sys/LICENSE",
"chars": 7651,
"preview": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007"
},
{
"path": "tracers-libelf-sys/bindgen.sh",
"chars": 681,
"preview": "#!/usr/bin/env bash\n#\n# Manually re-generate the Rust bindings. This isn't normally required\n# but if there's a change "
},
{
"path": "tracers-libelf-sys/build.rs",
"chars": 5288,
"preview": "//! This builds the `elfutils` package from vendored source. More specifically, it builds only\n//! that subset of `elfu"
},
{
"path": "tracers-libelf-sys/src/lib.h",
"chars": 21,
"preview": "#include <libelf.h>\n\n"
},
{
"path": "tracers-libelf-sys/src/lib.rs",
"chars": 623,
"preview": "#![allow(clippy::all)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case_types)]\n#![allow(non_snake_case)]\n\n// O"
},
{
"path": "tracers-libelf-sys/src/libelf.rs",
"chars": 137647,
"preview": "/* automatically generated by rust-bindgen */\n\npub const _LIBELF_H: u32 = 1;\npub const _STDINT_H: u32 = 1;\npub const _FE"
},
{
"path": "tracers-libelf-sys/update-elfutils.sh",
"chars": 683,
"preview": "#!/usr/bin/env sh\n#\n# The elfutils code in the git repo is not ready to build from source\n# It's missing the `configure`"
},
{
"path": "tracers-libelf-sys/vendor/libelf/ABOUT-NLS",
"chars": 76502,
"preview": "1 Notes on the Free Translation Project\n***************************************\n\nFree software is going international! "
},
{
"path": "tracers-libelf-sys/vendor/libelf/AUTHORS",
"chars": 53,
"preview": "For Now:\nUlrich Drepper.\nRoland McGrath\nPetr Machata\n"
},
{
"path": "tracers-libelf-sys/vendor/libelf/CONTRIBUTING",
"chars": 4506,
"preview": "The project home is http://elfutils.org/\n\nThe current elfutils source code can be checked out with\ngit clone git://sourc"
},
{
"path": "tracers-libelf-sys/vendor/libelf/COPYING",
"chars": 35147,
"preview": " GNU GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free "
},
{
"path": "tracers-libelf-sys/vendor/libelf/COPYING-GPLV2",
"chars": 18092,
"preview": " GNU GENERAL PUBLIC LICENSE\n Version 2, June 1991\n\n Copyright (C) 1989, 1991 Fr"
},
{
"path": "tracers-libelf-sys/vendor/libelf/COPYING-LGPLV3",
"chars": 7651,
"preview": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007"
},
{
"path": "tracers-libelf-sys/vendor/libelf/ChangeLog",
"chars": 21732,
"preview": "2019-02-14 Mark Wielaard <mark@klomp.org>\n\n\t* configure.ac: Set version to 0.176.\n\t* NEWS: Mention riscv backend updat"
},
{
"path": "tracers-libelf-sys/vendor/libelf/GPG-KEY",
"chars": 7173,
"preview": "-----BEGIN PGP PUBLIC KEY BLOCK-----\n\nmQINBFxDPtIBEAC8xePaWvq5cDMBYtrpdmR20YX5xrDXUeHgueSVE9Mw8yCan2Cq\n1Ac1jHYnXxp4Jj3q4"
},
{
"path": "tracers-libelf-sys/vendor/libelf/INSTALL",
"chars": 15756,
"preview": "Installation Instructions\n*************************\n\n Copyright (C) 1994-1996, 1999-2002, 2004-2016 Free Software\nFoun"
},
{
"path": "tracers-libelf-sys/vendor/libelf/Makefile.am",
"chars": 1871,
"preview": "## Process this file with automake to create Makefile.in\n## Configure input file for elfutils.\n##\n## Copyright (C) 1996-"
},
{
"path": "tracers-libelf-sys/vendor/libelf/Makefile.in",
"chars": 29816,
"preview": "# Makefile.in generated by automake 1.16.1 from Makefile.am.\n# @configure_input@\n\n# Copyright (C) 1994-2018 Free Softwar"
},
{
"path": "tracers-libelf-sys/vendor/libelf/NEWS",
"chars": 43297,
"preview": "Version 0.176\n\nbuild: Add new --enable-install-elfh option.\n Do NOT use this for system installs (it overrides gli"
},
{
"path": "tracers-libelf-sys/vendor/libelf/NOTES",
"chars": 3037,
"preview": "Fundamental design decision:\n\n- the sizes of external and internal types are assumed to be the same.\n This leaves byte "
},
{
"path": "tracers-libelf-sys/vendor/libelf/README",
"chars": 1103,
"preview": "The elfutils project provides libraries and tools for ELF files and DWARF data.\n\nThe project home is http://elfutils.org"
},
{
"path": "tracers-libelf-sys/vendor/libelf/THANKS",
"chars": 193,
"preview": "At least the following have submitted valuable patches:\n\nJeff Johnson\t\tbuilding. rpm wrestling\nAlexander Larsson\tseparat"
},
{
"path": "tracers-libelf-sys/vendor/libelf/TODO",
"chars": 5447,
"preview": "\t\t ToDo list for elfutils -*-outline-*-\n ----------------------\n\nTime-sta"
},
{
"path": "tracers-libelf-sys/vendor/libelf/aclocal.m4",
"chars": 46230,
"preview": "# generated automatically by aclocal 1.16.1 -*- Autoconf -*-\n\n# Copyright (C) 1996-2018 Free Software Foundation, Inc.\n\n"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/ChangeLog",
"chars": 40934,
"preview": "2019-02-15 Mark Wielaard <mark@klomp.org>\n\n\t* s390_init.c (s390_init): Hook check_special_symbol.\n\t* s390_symbol.c (s3"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/Makefile.am",
"chars": 7083,
"preview": "## Process this file with automake to create Makefile.in\n##\n## Copyright (C) 2000-2010, 2013, 2014 Red Hat, Inc.\n## Copy"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/Makefile.in",
"chars": 57050,
"preview": "# Makefile.in generated by automake 1.16.1 from Makefile.am.\n# @configure_input@\n\n# Copyright (C) 1994-2018 Free Softwar"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/aarch64_cfi.c",
"chars": 2784,
"preview": "/* arm64 ABI-specified defaults for DWARF CFI.\n Copyright (C) 2013, 2018 Red Hat, Inc.\n This file is part of elfutil"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/aarch64_corenote.c",
"chars": 5360,
"preview": "/* AArch64 specific core note handling.\n Copyright (C) 2013 Red Hat, Inc.\n This file is part of elfutils.\n\n This f"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/aarch64_init.c",
"chars": 2149,
"preview": "/* Initialization of AArch64 specific backend library.\n Copyright (C) 2013, 2017 Red Hat, Inc.\n This file is part of"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/aarch64_initreg.c",
"chars": 2674,
"preview": "/* Fetch live process registers from TID.\n Copyright (C) 2013, 2014 Red Hat, Inc.\n This file is part of elfutils.\n\n "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/aarch64_regs.c",
"chars": 2848,
"preview": "/* Register names and numbers for AArch64 DWARF.\n Copyright (C) 2013, 2014 Red Hat, Inc.\n This file is part of elfut"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/aarch64_reloc.def",
"chars": 5687,
"preview": "/* List the relocation types for AArch64. -*- C -*-\n Copyright (C) 2013, 2014, 2015 Red Hat, Inc.\n This file is par"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/aarch64_retval.c",
"chars": 9479,
"preview": "/* Function return value location for Linux/AArch64 ABI.\n Copyright (C) 2013 Red Hat, Inc.\n This file is part of elf"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/aarch64_symbol.c",
"chars": 3254,
"preview": "/* AArch64 specific symbolic name handling.\n Copyright (C) 2013, 2015, 2017 Red Hat, Inc.\n This file is part of elfu"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/aarch64_unwind.c",
"chars": 2483,
"preview": "/* Get previous frame state for an existing frame state.\n Copyright (C) 2016 The Qt Company Ltd.\n This file is part "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/alpha_auxv.c",
"chars": 1418,
"preview": "/* Alpha-specific auxv handling.\n Copyright (C) 2008 Red Hat, Inc.\n This file is part of elfutils.\n\n This file is "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/alpha_corenote.c",
"chars": 2105,
"preview": "/* PowerPC specific core note handling.\n Copyright (C) 2007 Red Hat, Inc.\n This file is part of elfutils.\n\n This f"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/alpha_init.c",
"chars": 2086,
"preview": "/* Initialization of Alpha specific backend library.\n Copyright (C) 2002-2011 Red Hat, Inc.\n This file is part of el"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/alpha_regs.c",
"chars": 3611,
"preview": "/* Register names and numbers for Alpha DWARF.\n Copyright (C) 2007 Red Hat, Inc.\n This file is part of elfutils.\n\n "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/alpha_reloc.def",
"chars": 2024,
"preview": "/* List the relocation types for alpha. -*- C -*-\n Copyright (C) 2005 Red Hat, Inc.\n This file is part of elfutils."
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/alpha_retval.c",
"chars": 4008,
"preview": "/* Function return value location for Alpha ELF ABI.\n Copyright (C) 2005, 2007, 2014 Red Hat, Inc.\n This file is par"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/alpha_symbol.c",
"chars": 4234,
"preview": "/* Alpha specific symbolic name handling.\n Copyright (C) 2002-2011 Red Hat, Inc.\n This file is part of elfutils.\n "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/arm_attrs.c",
"chars": 6072,
"preview": "/* Object attribute tags for ARM.\n Copyright (C) 2009 Red Hat, Inc.\n This file is part of elfutils.\n\n This file is"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/arm_auxv.c",
"chars": 1416,
"preview": "/* ARM-specific auxv handling.\n Copyright (C) 2009 Red Hat, Inc.\n This file is part of elfutils.\n\n This file is fr"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/arm_cfi.c",
"chars": 2971,
"preview": "/* arm ABI-specified defaults for DWARF CFI.\n Copyright (C) 2013 Red Hat, Inc.\n This file is part of elfutils.\n\n T"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/arm_corenote.c",
"chars": 2713,
"preview": "/* ARM specific core note handling.\n Copyright (C) 2009, 2012 Red Hat, Inc.\n This file is part of elfutils.\n\n This"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/arm_init.c",
"chars": 2323,
"preview": "/* Initialization of Arm specific backend library.\n Copyright (C) 2002, 2005, 2009, 2013, 2014, 2015, 2017 Red Hat, In"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/arm_initreg.c",
"chars": 2709,
"preview": "/* Fetch live process registers from TID.\n Copyright (C) 2014 Red Hat, Inc.\n This file is part of elfutils.\n\n This"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/arm_regs.c",
"chars": 2830,
"preview": "/* Register names and numbers for ARM DWARF.\n Copyright (C) 2009 Red Hat, Inc.\n This file is part of elfutils.\n\n T"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/arm_reloc.def",
"chars": 4785,
"preview": "/* List the relocation types for arm. -*- C -*-\n Copyright (C) 2005-2010, 2014, 2015 Red Hat, Inc.\n This file is pa"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/arm_retval.c",
"chars": 3682,
"preview": "/* Function return value location for ARM EABI.\n Copyright (C) 2009-2010, 2014 Red Hat, Inc.\n This file is part of e"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/arm_symbol.c",
"chars": 4032,
"preview": "/* Arm specific symbolic name handling.\n Copyright (C) 2002-2009, 2014, 2015, 2017 Red Hat, Inc.\n This file is part "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/bpf_init.c",
"chars": 1692,
"preview": "/* Initialization of BPF specific backend library.\n This file is part of elfutils.\n\n This file is free software; you"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/bpf_regs.c",
"chars": 1633,
"preview": "/* Register names and numbers for BPF DWARF.\n This file is part of elfutils.\n\n This file is free software; you can r"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/bpf_reloc.def",
"chars": 1119,
"preview": "/* List the relocation types for BPF. -*- C -*-\n This file is part of elfutils.\n\n This file is free software; you c"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/bpf_symbol.c",
"chars": 1504,
"preview": "/* BPF specific symbolic name handling.\n This file is part of elfutils.\n\n This file is free software; you can redist"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/common-reloc.c",
"chars": 4171,
"preview": "/* Common code for ebl reloc functions.\n Copyright (C) 2005, 2006 Red Hat, Inc.\n This file is part of elfutils.\n\n "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/i386_auxv.c",
"chars": 1677,
"preview": "/* i386 specific auxv handling.\n Copyright (C) 2007 Red Hat, Inc.\n This file is part of elfutils.\n\n This file is f"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/i386_cfi.c",
"chars": 2196,
"preview": "/* i386 ABI-specified defaults for DWARF CFI.\n Copyright (C) 2009 Red Hat, Inc.\n This file is part of elfutils.\n\n "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/i386_corenote.c",
"chars": 4199,
"preview": "/* i386 specific core note handling.\n Copyright (C) 2007-2010 Red Hat, Inc.\n This file is part of elfutils.\n\n This"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/i386_init.c",
"chars": 2161,
"preview": "/* Initialization of i386 specific backend library.\n Copyright (C) 2000-2009, 2013, 2017 Red Hat, Inc.\n This file is"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/i386_initreg.c",
"chars": 2626,
"preview": "/* Fetch live process registers from TID.\n Copyright (C) 2013 Red Hat, Inc.\n This file is part of elfutils.\n\n This"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/i386_regs.c",
"chars": 3359,
"preview": "/* Register names and numbers for i386 DWARF.\n Copyright (C) 2005, 2006, 2007 Red Hat, Inc.\n This file is part of el"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/i386_reloc.def",
"chars": 2300,
"preview": "/* List the relocation types for i386.\t-*- C -*-\n Copyright (C) 2000, 2001, 2002, 2003, 2005, 2009, 2015 Red Hat, Inc."
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/i386_retval.c",
"chars": 3833,
"preview": "/* Function return value location for Linux/i386 ABI.\n Copyright (C) 2005-2010, 2014 Red Hat, Inc.\n This file is par"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/i386_symbol.c",
"chars": 2095,
"preview": "/* i386 specific symbolic name handling.\n Copyright (C) 2000, 2001, 2002, 2005 Red Hat, Inc.\n This file is part of e"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/i386_syscall.c",
"chars": 1515,
"preview": "/* Linux/i386 system call ABI in DWARF register numbers.\n Copyright (C) 2008 Red Hat, Inc.\n This file is part of elf"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/i386_unwind.c",
"chars": 2581,
"preview": "/* Get previous frame state for an existing frame state using frame pointers.\n Copyright (C) 2017 Red Hat, Inc.\n Thi"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/ia64_init.c",
"chars": 2041,
"preview": "/* Initialization of IA-64 specific backend library.\n Copyright (C) 2002, 2003, 2005, 2006, 2007, 2014 Red Hat, Inc.\n "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/ia64_regs.c",
"chars": 6412,
"preview": "/* Register names and numbers for IA64 DWARF.\n Copyright (C) 2006 Red Hat, Inc.\n This file is part of elfutils.\n\n "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/ia64_reloc.def",
"chars": 3677,
"preview": "/* List the relocation types for ia64. -*- C -*-\n Copyright (C) 2005, 2006, 2015 Red Hat, Inc.\n This file is part o"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/ia64_retval.c",
"chars": 10116,
"preview": "/* Function return value location for IA64 ABI.\n Copyright (C) 2006-2010, 2014 Red Hat, Inc.\n This file is part of e"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/ia64_symbol.c",
"chars": 3925,
"preview": "/* IA-64 specific symbolic name handling.\n Copyright (C) 2002-2009, 2014 Red Hat, Inc.\n This file is part of elfutil"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/libebl_CPU.h",
"chars": 2351,
"preview": "/* Common interface for libebl modules.\n Copyright (C) 2000, 2001, 2002, 2003, 2005, 2013, 2014 Red Hat, Inc.\n This "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/linux-core-note.c",
"chars": 8747,
"preview": "/* Common core note type descriptions for Linux.\n Copyright (C) 2007-2010 Red Hat, Inc.\n Copyright (C) H.J. Lu <hjl."
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/m68k_cfi.c",
"chars": 1758,
"preview": "/* m68k ABI-specified defaults for DWARF CFI.\n This file is part of elfutils.\n\n This file is free software; you can "
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/m68k_corenote.c",
"chars": 2145,
"preview": "/* M68K specific core note handling.\n This file is part of elfutils.\n\n This file is free software; you can redistrib"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/m68k_init.c",
"chars": 1865,
"preview": "/* Initialization of M68K specific backend library.\n This file is part of elfutils.\n\n This file is free software; yo"
},
{
"path": "tracers-libelf-sys/vendor/libelf/backends/m68k_initreg.c",
"chars": 2371,
"preview": "/* Fetch live process registers from TID.\n This file is part of elfutils.\n\n This file is free software; you can redi"
}
]
// ... and 1266 more files (download for full content)
About this extraction
This page contains the full source code of the anelson/tracers GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1466 files (9.7 MB), approximately 2.6M tokens, and a symbol index with 6077 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.