rizin-0.7.4/ 0000775 0001750 0001750 00000000000 14731035230 012215 5 ustar sophie sophie rizin-0.7.4/COPYING.LESSER 0000664 0001750 0001750 00000016743 14731035230 014257 0 ustar sophie sophie GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.
0. Additional Definitions.
As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.
"The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.
An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.
A "Combined Work" is a work produced by combining or linking an
Application with the Library. The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".
The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.
The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.
1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.
2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:
a) under this License, provided that you make a good faith effort to
ensure that, in the event an Application does not supply the
function or data, the facility still operates, and performs
whatever part of its purpose remains meaningful, or
b) under the GNU GPL, with none of the additional permissions of
this License applicable to that copy.
3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from
a header file that is part of the Library. You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:
a) Give prominent notice with each copy of the object code that the
Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the object code with a copy of the GNU GPL and this license
document.
4. Combined Works.
You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:
a) Give prominent notice with each copy of the Combined Work that
the Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the Combined Work with a copy of the GNU GPL and this license
document.
c) For a Combined Work that displays copyright notices during
execution, include the copyright notice for the Library among
these notices, as well as a reference directing the user to the
copies of the GNU GPL and this license document.
d) Do one of the following:
0) Convey the Minimal Corresponding Source under the terms of this
License, and the Corresponding Application Code in a form
suitable for, and under terms that permit, the user to
recombine or relink the Application with a modified version of
the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.
1) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (a) uses at run time
a copy of the Library already present on the user's computer
system, and (b) will operate properly with a modified version
of the Library that is interface-compatible with the Linked
Version.
e) Provide Installation Information, but only if you would otherwise
be required to provide such information under section 6 of the
GNU GPL, and only to the extent that such information is
necessary to install and execute a modified version of the
Combined Work produced by recombining or relinking the
Application with a modified version of the Linked Version. (If
you use option 4d0, the Installation Information must accompany
the Minimal Corresponding Source and Corresponding Application
Code. If you use option 4d1, you must provide the Installation
Information in the manner specified by section 6 of the GNU GPL
for conveying Corresponding Source.)
5. Combined Libraries.
You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:
a) Accompany the combined library with a copy of the same work based
on the Library, uncombined with any other library facilities,
conveyed under the terms of this License.
b) Give prominent notice with the combined library that part of it
is a work based on the Library, and explaining where to find the
accompanying uncombined form of the same work.
6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.
rizin-0.7.4/dist/ 0000775 0001750 0001750 00000000000 14731035230 013160 5 ustar sophie sophie rizin-0.7.4/dist/deb/ 0000775 0001750 0001750 00000000000 14731035230 013712 5 ustar sophie sophie rizin-0.7.4/dist/deb/rizin.dsc 0000664 0001750 0001750 00000001021 14731035230 015532 0 ustar sophie sophie Format: 1.0
Source: rizin
Binary: rizin, librizin-dev, rizin-common
Architecture: any all
Version: 0.4.0-1
Maintainer: RizinOrg
Homepage: https://rizin.re/
Standards-Version: 4.5.1
Vcs-Browser: https://github.com/rizinorg/rizin
Vcs-Git: https://github.com/rizinorg/rizin
Build-Depends: debhelper (>= 12), meson (>= 0.55.0), ninja-build, pkg-config, python3, python3-setuptools
Package-List:
rizin deb devel optional arch=any
rizin-common deb devel optional arch=all
librizin-dev deb libdevel optional arch=any
rizin-0.7.4/dist/deb/debian.librizin-dev.install 0000664 0001750 0001750 00000000101 14731035230 021111 0 ustar sophie sophie usr/include
usr/lib/*/pkgconfig
usr/lib/*/*.so
usr/lib/*/cmake/*
rizin-0.7.4/dist/deb/debian.compat 0000664 0001750 0001750 00000000003 14731035230 016332 0 ustar sophie sophie 13
rizin-0.7.4/dist/deb/debian.control 0000664 0001750 0001750 00000002331 14731035230 016535 0 ustar sophie sophie Source: rizin
Section: devel
Priority: optional
Maintainer: RizinOrg
Build-Depends: debhelper (>= 12),
meson,
ninja-build,
pkg-config,
python3,
python3-setuptools,
Standards-Version: 4.5.1
Homepage: https://rizin.re/
Vcs-Browser: https://github.com/rizinorg/rizin
Vcs-Git: https://github.com/rizinorg/rizin
Rules-Requires-Root: no
Package: rizin
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: Free and Open Source Reverse Engineering Framework
Rizin is a free and open-source Reverse Engineering framework, providing a
complete binary analysis experience with features like Disassembler,
Hexadecimal editor, Emulation, Binary inspection, Debugger, and more.
Package: librizin-dev
Section: libdevel
Architecture: any
Depends: ${misc:Depends}, librizin-common (>= ${source:Version}), rizin (>= ${source:Version})
Description: devel files from the rizin suite
This package provides the devel files from rizin.
Package: librizin-common
Multi-Arch: foreign
Architecture: all
Depends: ${misc:Depends}
Description: arch independent files from the rizin suite
This package provides the arch independent files from rizin.
rizin-0.7.4/dist/deb/debian.librizin-common.install 0000664 0001750 0001750 00000000021 14731035230 021624 0 ustar sophie sophie /usr/share/rizin
rizin-0.7.4/dist/deb/debian.rules 0000775 0001750 0001750 00000002636 14731035230 016222 0 ustar sophie sophie #!/usr/bin/make -f
# See debhelper(7) (uncomment to enable)
# output every command that modifies files on the build system.
DEB_HOST_MULTIARCH ?= $(shell dpkg-architecture -qDEB_HOST_MULTIARCH)
DEB_UPSTREAM_VERSION ?= $(shell dpkg-parsechangelog | sed -rne 's/^Version: ([0-9.]+)[-+].*$$/\1/p')
EXTRA_FLAGS=
EXTRA_FLAGS+= --buildtype=release
EXTRA_FLAGS+= -Dpackager=RizinOrg
EXTRA_FLAGS+= -Dpackager_version=$(DEB_UPSTREAM_VERSION)
EXTRA_FLAGS+= -Dsubprojects_check=false
EXTRA_FLAGS+= -Dlocal=disabled
EXTRA_FLAGS+= -Duse_sys_capstone=disabled
EXTRA_FLAGS+= -Duse_sys_magic=disabled
EXTRA_FLAGS+= -Duse_sys_libzip=disabled
EXTRA_FLAGS+= -Duse_sys_zlib=disabled
EXTRA_FLAGS+= -Duse_sys_lz4=disabled
EXTRA_FLAGS+= -Duse_sys_xxhash=disabled
EXTRA_FLAGS+= -Duse_sys_openssl=disabled
# architectures with debugging support
DEBUG_SUPPORT=0
debug_architectures := i386 amd64 arm arm64 mips mips64 powerpc ppc64
ifeq ($(DEB_HOST_ARCH_CPU),$(findstring $(DEB_HOST_ARCH_CPU),$(debug_architectures)))
DEBUG_SUPPORT=1
endif
ifeq (0,$(DEBUG_SUPPORT))
EXTRA_FLAGS+= -Ddebugger=false
else
EXTRA_FLAGS+= -Ddebugger=true
endif
%:
dh $@ --buildsystem=meson
override_dh_auto_configure:
dh_auto_configure --builddirectory=build-deb -- ${EXTRA_FLAGS}
override_dh_auto_build:
dh_auto_build --builddirectory=build-deb
override_dh_auto_test:
# skip tests
override_dh_auto_install:
dh_auto_install --builddirectory=build-deb # --destdir=debian/tmp
rizin-0.7.4/dist/deb/debian.changelog 0000664 0001750 0001750 00000000247 14731035230 017010 0 ustar sophie sophie rizin (0.3.0-1) rolling; urgency=medium
* First import from Parrot of the debian package
-- Riccardo Schirone Thu, 7 Oct 2021 16:42:00 +0700
rizin-0.7.4/dist/deb/README.md 0000664 0001750 0001750 00000001134 14731035230 015170 0 ustar sophie sophie These files are mainly created to support the
[Open Build Service](https://build.opensuse.org/package/show/home:RizinOrg/rizin), with the
[debtransform](https://raw.githubusercontent.com/openSUSE/obs-build/master/debtransform)
tool.
For example:
```
$ mkdir outdir
$ perl ./debtransform --changelog debian.changelog --release 0.3.0-1 . rizin.dsc outdir
```
If you want to build for an older version of Debian/Ubuntu that required special
patches, you can use a different .dsc file:
```
$ mkdir outdir
$ perl ./debtransform --changelog debian.changelog --release 0.3.0-1 . rizin-Debian_10.dsc outdir
``` rizin-0.7.4/dist/deb/debian.rizin.install 0000664 0001750 0001750 00000000077 14731035230 017662 0 ustar sophie sophie usr/bin
usr/lib/*/*.so.*
usr/share/man/man1
usr/share/man/man7
rizin-0.7.4/dist/windows/ 0000775 0001750 0001750 00000000000 14731035230 014652 5 ustar sophie sophie rizin-0.7.4/dist/windows/build_windows_installer.ps1 0000664 0001750 0001750 00000001641 14731035230 022227 0 ustar sophie sophie $name=$args[0]
$bits=$args[1]
$end=$args.Length
$meson_options=$args[2..$end]
$scriptpath=$PSScriptRoot
$builddir=$(Join-Path -Path $env:TEMP -ChildPath "build-win-installer-$name-$bits")
$installdir=$(Join-Path -Path $env:TEMP -ChildPath "rizin-win-installer-$name-$bits")
pushd $PSScriptRoot\..\..
$version=$(python sys\version.py)
echo $version
echo $builddir
echo $installdir
$env:Path += ";$env:ProgramFiles (x86)\Microsoft Visual Studio\Installer"
$env:Path += ";$env:ProgramFiles\7-Zip"
$env:Path += ";$env:ProgramFiles (x86)\Inno Setup 6"
dist\windows\vsdevenv.ps1 $bits
meson --buildtype=release --prefix=$installdir $builddir $meson_options
ninja -C $builddir -j1
ninja -C $builddir install
7z a dist\windows\Output\rizin-$name-$version.zip $installdir
iscc dist\windows\rizin.iss /DRizinLocation=$installdir\* /DLicenseLocation=$PWD\COPYING.LESSER /DMyAppVersion=$version
rm -r $builddir
rm -r $installdir
popd
rizin-0.7.4/dist/windows/vsdevenv.ps1 0000664 0001750 0001750 00000000723 14731035230 017141 0 ustar sophie sophie $bits = $args[0]
$installationPath = vswhere.exe -latest -property installationPath
if (-not $installationPath -or -not (test-path "$installationPath\VC\Auxiliary\Build\vcvars$bits.bat")) {
throw "vcvars$bits.bat file not found"
}
& "${env:COMSPEC}" /s /c "`"$installationPath\VC\Auxiliary\Build\vcvars$bits.bat`" > nul 2>&1 && set" | . { process {
if ($_ -match '^([^=]+)=(.*)') {
[System.Environment]::SetEnvironmentVariable($matches[1], $matches[2])
}
}} rizin-0.7.4/dist/windows/rizin.ico 0000664 0001750 0001750 00000035356 14731035230 016515 0 ustar sophie sophie 00 % 6 % h 6 ( 0 ` $
2 j j 2
! j j ! $ "0@NVVN@0" $ k )PP) k * 3ww3 * F (rr( F T DD T P `` P ; oDAo ; jH > j U_" }R U K 7~0 f* 6 J !6\ SK o U S'52 {|+ n$S U #M6h& Z" oM# 5 M 6Y"N"o M 5 w M 6o M w ,% .U %, $ L 4 L $ H rQ / Qr H k 6 P 6 k ) w2 ) ## W ## $" 2 "$ ## &D ## ( %A ( n 4 Cc& 4 n L vM "*=cxI0$! Mu L ( PyMy yO ( /"+H"/ ~ G&=G ~ ; S g~v0 S ; &7>U:& _ 6XX- ^ #|uo] V @? U axcrgb & y]@Zy & I !~ms~! H ` pHxZrp ` e Qvv= l,:bQ e W 0^hzoI`2 W 9 &`n" 9 2aa1 3 (;O_>-UP;( 3 0 0 = s s = + 2 2 + ? ? ( @ % h h % 0 !0@JJ@0! 0 ~ ;ww; } ) 77 ) 1 __ 1 $ ww $
sR eg%>r
h Tq' U1 =T h -YM Md! = 0.55.0
%if 0%{?suse_version}
BuildRequires: ninja
%else
BuildRequires: ninja-build
%endif
BuildRequires: pkgconfig
Requires: %{name}-common = %{version}-%{release}
%description
Rizin is a free and open-source Reverse Engineering framework, providing a
complete binary analysis experience with features like Disassembler,
Hexadecimal editor, Emulation, Binary inspection, Debugger, and more.
Rizin is a fork of radare2 with a focus on usability, working features and code
cleanliness.
%package devel
Summary: Development files for the rizin package
Requires: %{name}%{?_isa} = %{version}-%{release}
Requires: file-devel
Requires: openssl-devel
%description devel
Development files for the rizin package. See rizin package for more
information.
%package common
Summary: Arch-independent SDB files for the rizin package
BuildArch: noarch
Requires: %{name} = %{version}-%{release}
%description common
Arch-independent SDB files used by rizin package. See rizin package for more
information
%prep
# Build from git release version
%setup -n %{name}-v%{version}
%build
# Whereever possible use the system-wide libraries instead of bundles
%meson \
%ifarch s390x
-Ddebugger=false \
%endif
-Denable_tests=false \
-Denable_rz_test=false \
-Dlocal=disabled \
-Dpackager="RizinOrg" \
-Dpackager_version="%{version}-%{release}"
%meson_build
%install
%meson_install
%if 0%{?suse_version} || (0%{?centos} && 0%{?centos} < 8)
%post -p /sbin/ldconfig
%postun -p /sbin/ldconfig
%else
%ldconfig_scriptlets
%endif
%check
# Do not run the unit testsuite yet - it pulls another big repository
# https://github.com/rizinorg/rizin-testbins from github
%files
%doc CONTRIBUTING.md DEVELOPERS.md README.md SECURITY.md BUILDING.md
%license COPYING COPYING.LESSER
%{_bindir}/r*
%{_libdir}/librz_*.so.%{version}*
%{_libdir}/librz_*.so.%{shortversion}
%{_mandir}/man1/rizin.1.*
%{_mandir}/man1/rz*.1.*
%{_mandir}/man7/rz-esil.7.*
%files devel
%{_includedir}/librz
%{_libdir}/librz*.so
%{_libdir}/pkgconfig/*.pc
%{_libdir}/cmake/**/*.cmake
%dir %{_libdir}/cmake
%dir %{_libdir}/cmake/**
%files common
%{_datadir}/%{name}/asm
%{_datadir}/%{name}/cons
%{_datadir}/%{name}/flag
%{_datadir}/%{name}/format
%{_datadir}/%{name}/fortunes
%{_datadir}/%{name}/hud
%{_datadir}/%{name}/magic
%{_datadir}/%{name}/opcodes
%{_datadir}/%{name}/reg
%{_datadir}/%{name}/syscall
%{_datadir}/%{name}/types
%dir %{_datadir}/%{name}
%changelog
* Mon Sep 27 2021 Riccardo Schirone - 0.0.5-1
- Initial spec file from upstream
rizin-0.7.4/dist/osx/ 0000775 0001750 0001750 00000000000 14731035230 013771 5 ustar sophie sophie rizin-0.7.4/dist/osx/rizin.unpkg/ 0000775 0001750 0001750 00000000000 14731035230 016247 5 ustar sophie sophie rizin-0.7.4/dist/osx/rizin.unpkg/PackageInfo 0000664 0001750 0001750 00000000713 14731035230 020342 0 ustar sophie sophie
rizin-0.7.4/dist/osx/Resources/ 0000775 0001750 0001750 00000000000 14731035230 015743 5 ustar sophie sophie rizin-0.7.4/dist/osx/Resources/COPYING.LESSER 0000664 0001750 0001750 00000016743 14731035230 020005 0 ustar sophie sophie GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
This version of the GNU Lesser General Public License incorporates
the terms and conditions of version 3 of the GNU General Public
License, supplemented by the additional permissions listed below.
0. Additional Definitions.
As used herein, "this License" refers to version 3 of the GNU Lesser
General Public License, and the "GNU GPL" refers to version 3 of the GNU
General Public License.
"The Library" refers to a covered work governed by this License,
other than an Application or a Combined Work as defined below.
An "Application" is any work that makes use of an interface provided
by the Library, but which is not otherwise based on the Library.
Defining a subclass of a class defined by the Library is deemed a mode
of using an interface provided by the Library.
A "Combined Work" is a work produced by combining or linking an
Application with the Library. The particular version of the Library
with which the Combined Work was made is also called the "Linked
Version".
The "Minimal Corresponding Source" for a Combined Work means the
Corresponding Source for the Combined Work, excluding any source code
for portions of the Combined Work that, considered in isolation, are
based on the Application, and not on the Linked Version.
The "Corresponding Application Code" for a Combined Work means the
object code and/or source code for the Application, including any data
and utility programs needed for reproducing the Combined Work from the
Application, but excluding the System Libraries of the Combined Work.
1. Exception to Section 3 of the GNU GPL.
You may convey a covered work under sections 3 and 4 of this License
without being bound by section 3 of the GNU GPL.
2. Conveying Modified Versions.
If you modify a copy of the Library, and, in your modifications, a
facility refers to a function or data to be supplied by an Application
that uses the facility (other than as an argument passed when the
facility is invoked), then you may convey a copy of the modified
version:
a) under this License, provided that you make a good faith effort to
ensure that, in the event an Application does not supply the
function or data, the facility still operates, and performs
whatever part of its purpose remains meaningful, or
b) under the GNU GPL, with none of the additional permissions of
this License applicable to that copy.
3. Object Code Incorporating Material from Library Header Files.
The object code form of an Application may incorporate material from
a header file that is part of the Library. You may convey such object
code under terms of your choice, provided that, if the incorporated
material is not limited to numerical parameters, data structure
layouts and accessors, or small macros, inline functions and templates
(ten or fewer lines in length), you do both of the following:
a) Give prominent notice with each copy of the object code that the
Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the object code with a copy of the GNU GPL and this license
document.
4. Combined Works.
You may convey a Combined Work under terms of your choice that,
taken together, effectively do not restrict modification of the
portions of the Library contained in the Combined Work and reverse
engineering for debugging such modifications, if you also do each of
the following:
a) Give prominent notice with each copy of the Combined Work that
the Library is used in it and that the Library and its use are
covered by this License.
b) Accompany the Combined Work with a copy of the GNU GPL and this license
document.
c) For a Combined Work that displays copyright notices during
execution, include the copyright notice for the Library among
these notices, as well as a reference directing the user to the
copies of the GNU GPL and this license document.
d) Do one of the following:
0) Convey the Minimal Corresponding Source under the terms of this
License, and the Corresponding Application Code in a form
suitable for, and under terms that permit, the user to
recombine or relink the Application with a modified version of
the Linked Version to produce a modified Combined Work, in the
manner specified by section 6 of the GNU GPL for conveying
Corresponding Source.
1) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (a) uses at run time
a copy of the Library already present on the user's computer
system, and (b) will operate properly with a modified version
of the Library that is interface-compatible with the Linked
Version.
e) Provide Installation Information, but only if you would otherwise
be required to provide such information under section 6 of the
GNU GPL, and only to the extent that such information is
necessary to install and execute a modified version of the
Combined Work produced by recombining or relinking the
Application with a modified version of the Linked Version. (If
you use option 4d0, the Installation Information must accompany
the Minimal Corresponding Source and Corresponding Application
Code. If you use option 4d1, you must provide the Installation
Information in the manner specified by section 6 of the GNU GPL
for conveying Corresponding Source.)
5. Combined Libraries.
You may place library facilities that are a work based on the
Library side by side in a single library together with other library
facilities that are not Applications and are not covered by this
License, and convey such a combined library under terms of your
choice, if you do both of the following:
a) Accompany the combined library with a copy of the same work based
on the Library, uncombined with any other library facilities,
conveyed under the terms of this License.
b) Give prominent notice with the combined library that part of it
is a work based on the Library, and explaining where to find the
accompanying uncombined form of the same work.
6. Revised Versions of the GNU Lesser General Public License.
The Free Software Foundation may publish revised and/or new versions
of the GNU Lesser General Public License from time to time. Such new
versions will be similar in spirit to the present version, but may
differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the
Library as you received it specifies that a certain numbered version
of the GNU Lesser General Public License "or any later version"
applies to it, you have the option of following the terms and
conditions either of that published version or of any later version
published by the Free Software Foundation. If the Library as you
received it does not specify a version number of the GNU Lesser
General Public License, you may choose any version of the GNU Lesser
General Public License ever published by the Free Software Foundation.
If the Library as you received it specifies that a proxy can decide
whether future versions of the GNU Lesser General Public License shall
apply, that proxy's public statement of acceptance of any version is
permanent authorization for you to choose that version for the
Library.
rizin-0.7.4/dist/osx/Resources/welcome.rtf 0000664 0001750 0001750 00000000650 14731035230 020114 0 ustar sophie sophie {\rtf1\ansi\ansicpg1252\cocoartf1265\cocoasubrtf210
{\fonttbl\f0\fswiss\fcharset0 Helvetica;}
{\colortbl;\red255\green255\blue255;}
\margl1440\margr1440\vieww10800\viewh6300\viewkind0
\pard\tx720\tx1440\tx2160\tx2880\tx3600\tx4320\tx5040\tx5760\tx6480\tx7200\tx7920\tx8640\pardirnatural
\f0\fs28 \cf0 \
\
You will be guided through the steps necessary to\
install this software.\
\
This will install Rizin to /usr/local} rizin-0.7.4/dist/osx/Resources/COPYING 0000664 0001750 0001750 00000104513 14731035230 017002 0 ustar sophie sophie GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
.
rizin-0.7.4/dist/osx/Resources/rizin-logo.png 0000664 0001750 0001750 00000041275 14731035230 020553 0 ustar sophie sophie PNG
IHDR l Z| gAMA a cHRM z& u0 ` : pQ< bKGD C tIME $J AIDATxw w}ܾ˒-r LOPb: i` z ЂӒ i!j͖e[eK՛:3 Wҽ[W߯stdf\k_$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$Itj N%3ӡ 0
Sw=MF` pہZz$I b`C L@ SہZ`_
o$=ƑKGg)v +?̥Glx$g`!. \I6y2i;`ˑ'$I:u=[ PiL'@$ٷ֎ߓ6_cR#澀҂W(D#P EnòmA n[ﺖ6wE<JV k%I p6@\@I)(.{hu_Eneq${蘆4<8Z44JgavQgFSsٳ9ЖԶXEj$m&Mn&4Jg_ !^Ik 3ؼMarJ ֦=w@1Ai9/8]<]2Ai2[hnoY澘+9fiLRJ.Zn&se_L6=iB}'/D=hY
ӰI S_ݷFt)O#7tJZʅגDKϑ]9D҃?pxT)؎k$XЏM|$3^KnE W~ 0o(^&%/]r M~YHu3IuS:3-ruv|ʸJ햷X ٪ϰ@X@8,r F
IGS<&\aPuߤ
>ʅ0Or`
UỤZA~q6I 8d`;">< ӄ0i/x ڞ#m ^Bv &>͵-Z[Im'w.yu=U0k4ʒO!IFox%e k++ 9Om{M IzWFH46~]ג_= m$=0IM ZL8j?B ZN=+F/$AܔQ3-
k aЄ527qAϟ'P澰mXSMxi}u@a注\ir s]H
lm}~ZFr/rO}Gv,@Kn#~a)zIPz1R!̹Ij7DScDܤ o $ÎFϢr(}IPBu% ItRd B0T.0Ѩ3>%y#Dl@y
sG",O#(U^d컛xM*~N{1)-z#oƺ 3AR|t~ o̞` M lBAx7M!,R<(-~'Aqb۳+ + G.3΄\wQ1 _Ɓ?]L}JS(\h-v2E$-{Wv8Hg&$-! dIt,N+U+"%ʔxM6_-*w<3~ Ѩ3 ;N뮇Fa]m5jw}m&7OkB7Զ{':> sDcυA>N (|&sGX6X=Fl$H'}`;"2!myn~S(>ʀB MlEVtlSzA\EAw km-
߃D8jͽge'&Mw]Kc]CqܔQ>#$Rm}6h,30uH8bai"h$>Oy<QE Mo q6II z > g ^J; uߠ{H$(#xH?$7nI6_櫔| W u<7"#۩i\V M~Shm}VfjLNjڝ !m'Q>m'}7$x툞W
0xMàiOQ[.V ,?[ =w> ]R
s܄SZt
?k};74hӀ7RmΝx3_Q~X{$Ij5|.^O_2MCnDck{^4b3hm
!m%֎?ﾍxAOńI$7q9/SzDՃT7Qڞ lvg$I"'e`C3x0iB8 Jg;&[4px
Aa A~$i $9֮e46Aa O0G;~7\@XDڽş ؞iAHj+?Ae'r ]LcH; vƆ_CXH8 s_HP@U.hƦ& D㖐&\Bq \Ir`
Mj |_O"$=t|vJPCi5oh/DSL~cGU2ڗPM[I477
ߣ0fЕ6컛t Is7(ynǞvxJ{մg=/{'^Ot0%MDϒԶhJghb>> Q]F)y>)#ȍ ȏkWh xPMq^yv!^Sn
wѸ_hn( CP ?Dc'{>9ϣ<~Mi5Dc#m6m+kg]1tK&_zB5 ,_M4|w}<[12CG E4LQgR;X5E?) 1¿z=+7{$IGӫw-HnT. I>a
23@.Żo'n"?pE.!UhmM !*DÞe/47|2>8M$ ")0 쀤ֶ_S$, lQ
3^Gasi7+[:hY}4hy ӄ܄S>=}n-2=,Rբ]1E
/fl$ m%=+I&ߦ釄ʼn#= fYx.
}tXI;o"}6Aq($7b>MRJXyرCX=نmhCΏ1. \?d/Fal<PֻӸFkBdu;Vr4]Oa xAXk)u >+-;JS# <$ZFk il)br/=M>fC ȏ!,M&^i"~
q ' 8*Imk6lM4F4\
3ܤGD%Z=XkYoY!H7 3ƺ쫗 < <HwU@G=1M|K>OگQmV ~=a1"͏?-+YUGMk i[O}"WVfR_u udģ1aHo&K>OGch"Aq"9W|9ay*)Im+?]]7^HPHkOI{𥳐漀Z}-BB67VaQIda 80O~:ƚg)ۅ AkωƜCi%? =|w(|ne47~Oﾕ m"(w
$(M&{'K)}>Ź/:}x:O͍߃y Gf?hmOO{*u$mCpBV֡{9$=t,@4Kne /nn9:4&(N0缀4 6f=h̹nK_ap<C|we=mAʒk4*tѸ inl%꾻;m4_Oyy d_Ls~!}A$= .|8%72G[i{\Kʅt wX-ʒ|9Ɂ5=saDZJXLO XvBaֳsg<'l 7Vo(,-ul$
ְ^g?+%ȍ ?q ۉw.%usޡ ϡrѧM| Aa op>5 4%7HBC y:>HGe 7!Iu3?F4l#8s7$IdaCG\'3Mhn!ik?um AT*Jn
W4:EcΡ|{ +ӏ>C+)} LB8r+nx]Ļu67EϡT$IlӁ΅72фu<'CR¾&A ~ 7lC=m4o15,:($Ilm ay
LcZ~kAJ Ai5f_1 ԗs?@5i}[kTQ cX \8ܟMSp8)%ufsIm+[z} wꓲGJ!i^DaK rgA@r`-;_{j볗c?ISp 9ԎVDH<?|&An ܋. V{{d$IҀ
g`=G?Ƥ-'R->3GSZJg8Z uD%H;=XJtB ?N IA!=l) PO{1W 6w]K![shs+nv?cOt%ȏdHT*MKa[:W HcU OxkMݴp(VSpJZ4~] n):cn2wyM?tλMx/zH[qHݥqOѣA&IP XCҘhbJ)
xRoʅ {>՛Lc͗{B o:@S[a
MHҽ tjҤAOCuiRR2ӟBcy} !kI چI^4>kA 07 n?ሹprӞBVfdXCR<,5v 6CqfA@4MIA㑤q *=DcΡpڋ8 QC89ϣt{x[9
s_Hgxʎim=7^E:@eɵ>sы(/8ј^&kֱ@ZIP O?zߢ"ΪO}iv|)ATYF\!- &ICIardz1BqK KYu7 Jޜ-cc~ꓨ,8ik GݣTk>E4婔 ERcGM{hm98vs 3iu#7^IkY
4;la{$IZ'ߐ(@W' ]Ӕ8pB =wP]Z+\!
PhT.Ae&եفN}է rS@Vf^Ai)l%67e 7RxMʅ$ȏ{kin ae&a / ?+q-ى%I҃p.:\H"nxa3vmQ4S g<_ ȏZ1gk >LmG $ 477_NBT Dy
AH:ʅk0o8W}rpa'gCV|ܸ(_ACXDR}{>Ok2缗8laeZ𠍤gHc`vL7$!j8{֑ h[=&ʧI' <ޡ $?&]F4,u#,b,mz: QW|9AT" qZϑ4IӸzѸ 3$Mr@ܗ]GU(:ӞLI50:^Pxlұa]$ e8=@h
T7ն{q5vl/7)#('*uXqPZpUsAH4zQO_MwP\*r ܠ44Wot_q&7#}Ob4 ga@DԳIG>;yo&IsHt
=;Z 3 ӄh}N1jw#Aq?"c1xRoxmqX}KR_y-ai2ߠz5$M>ȏ"7 w-M c;%
|
]%Iz9l2ic'Iz܄K4,G햷XU ru/Iu#7xA нQT.?Kn}V~jЅFHcw)-EQ9{m@&\L0Иdé6ve=lC`76Ie8vCWL@wｳ$%ȍ {~g&yŞN ˶ȏ{khnn4 hKhxJgiKS} {^N&{?Das!,8*KUN\@P6=٢1;J#
{|3I4h^qc4zaqFT~fk JvK>N~_ Ĩ|hEToy{UeZ'jw~P>zDqUY!?7 V3nK_iJkMg {. ?I4b 7g%hڳa1,[p玞=:{-$I
l 7q0ߡ) 6vS R]:$*}߷4@a_Sc'澣Kf6=RAHaֳ\1kJp#4~eW ?vEm*$R{W lAYxkײz,d$( ؖ; :,( &>^3 ҄ܤK JS.}-
PRR~.:{'A7PZ&M7P){GerOU q]L$?=ߧ1z Ԗv
f>{$n8ajRZGaK{V2 .9ܸ%47! \Aa,$(M~hJg_
=z<8wǗ&MR^NʬAw|S[a&"?i TV>(M KH* t[ SHvnoxk K)_Q31Or FOOa3))=낰NRr MXn?6v 78MA 6d{q}̶h&Z[گ_mh >!r 斟tok8t/Y($I`X簍yZvg6d; h#kݷve0Y47~dߪ)v4i8܄?inuIk粬xKFv>A~^DUڟQNsr;/ ItLNE}x90Ci}S {~@VfR|jo؇F DcWZI^Z[~J}Ww|=ZIm+
liBnMxdS[~_աJ4x'S`[G S}EǒLIkimqmqҸJki" K!g,i虘?@q}ql8ZkoP &!̠8o!̷?ƺ J $ {`5,Z9fe@ZJcW){VۀRJ=w6p<
J'~}VauG۶s){@kߌ]{ w,>)M? uK[:wMc5?#[ضG tr M+䁓R_47|7 OA9 icw XCch6i}[ +M~ -4|9[yFkC$=W/ j36vҸ_Ɯ۶\AHqˉwLkOhCso$Vw4!;d[5HdS:}SXu=+[Mඡ}@I zN唇>Y/[{AH_Χ&R\x5ay/@HSZ~G
WR==a-d`ïiIRZHWQ]^\8CوJ\E4ŻokۍPIIzB
|lN[uw_LAL\RJmUeXHַS[Qox%?c_P f5|VH{֯beII؎} !ޕW}:[Aa(}I<ֺtP_L1f{ox% m8ҡɢ KYz[~> It|NcΎ'
ߥtyg\EaӏҸJѽ5;o$<էi\Ktx8a
A[=w't<-}+U3$NgFRZt
ј d*>ӳb80!ɁY/]m-8.8Yo# 1]0IB|?]$t/X $ٿ s?4AERZ&&#Nګ#-ꫮu߯ `wII؎, tp D* 0OaT.ܤGq<
<ϠrѧMy\[u<= Ic@o?=$ICI؎&徯Hi*{Zzh*~« Szzǎ^YƞKeɵ28;Zڊgڻ&I:) X ['왂X ϑ9yfA~ş#?a}eTv_ֶo6$!쁯>ob
Tڟ @\#uae'rS.'Cڽ![Yu>&?ܸ%WLnD#T7e)Mޤȍx?cw՛LwEZ{ j$ICl ޡ -# ZwD8bшNسah"rS.'*H{{BV=h9m:3 $k8r}T%8UTo~3eY]@ k$'u`BT`I x
D#O?G}$^q}
"
3hԂF0r $6#$?ωF5d`Zs@o+`X$D9i+TAHҽ-o;3FcΦ|՟Sk>ZAH 1F/|?PATn^DP?d!MWg_"nuKv ԫ p#p10A dPCQm k6)O }&is/Im AΊk&)'z *Qlʌ~}z[2g
`3*`$I'Ήk\B>/JO{1WG?`ϛѺW4}xǟ
cz sJ[hm5ûhG~Mooƺof[w`pYqw&I҉vJ68*=0R $? ]g !Ļn%o%?v ^xr&rSD.ꫮK>kTÚ$IS.Q 7iB4L '!ғXVj+>"e + |5I d`B^&Q<¼&Gy@n믧3=Zwo>aM)v )le4|_E~c!9ݷR_y -?.?
0$IlpTh[||@1A~iNaZ8N5Iu _k$M
x-?0I; ڦ }g.4%L'?f=kp!6vkLgEOo[}n<Ú$IA6,l> =;Qgaql1v[~Fc`Zlmװ&Iy68*3^m nY=^x[qpiJr`
-?{{WSJmp 8CÚ$IA:"- <
4 ('7bSD4ᒞ*'kK;wBshm5IƬ,=vghX$im{&^}78y YϨD"=è-Ҹ
F:@ m G
u W@;h#YϓC j$ 26m&Yp{ƻCNҞ}`v7/ >`P$ l n3" o '> JU"`X$T
l n
Lg JJ;$I|`;Mp˓D)ydadt YH[?$$I&7q[\<8
&dU V lnڎ#O4It3Cx+w;m>0) L tہ{doЦ'
j$=Cxl_Id擭4=ɂ@!$dlλzlC@C$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$I$Iz&~ %tEXtdate:create 2021-11-19T06:36:02+00:00Pj %tEXtdate:modify 2021-11-19T06:36:02+00:00!7 IENDB` rizin-0.7.4/dist/osx/build_osx_package.sh 0000775 0001750 0001750 00000002374 14731035230 020001 0 ustar sophie sophie #!/bin/sh -eu
#
# Script to create a OSX .pkg file to install Rizin
VERSION=$(python3 ./sys/version.py)
RIZINDIR=$(pwd)
RIZININSTALL=/tmp/rizin-install
OSXPKGDIR=/tmp/osxpkgtmp
rm -rf buildtmp
mkdir buildtmp
meson buildtmp --buildtype=release -Denable_tests=false -Dlocal=disabled --prefix=/usr/local
rm -rf "${RIZININSTALL}"
DESTDIR="${RIZININSTALL}" ninja -C buildtmp install
rm -rf buildtmp
rm -rf "${OSXPKGDIR}"
mkdir "${OSXPKGDIR}"
cp -rv "${RIZINDIR}/dist/osx/rizin.unpkg/" "${OSXPKGDIR}/"
cd "${RIZININSTALL}" && find . | cpio -o --format odc | gzip -c > "${OSXPKGDIR}/Payload"
mkbom "${RIZININSTALL}" "${OSXPKGDIR}/Bom"
pkgutil --flatten "${OSXPKGDIR}" "${RIZINDIR}/dist/osx/rizin.pkg"
convert -size 620x418 xc:none -background none /tmp/bg.png || { echo convert failed, is imagemagick installed?; exit 1; }
composite -geometry +30+230 -background none \( "${RIZINDIR}/doc/img/rizin.svg" -resize 25% \) /tmp/bg.png -colorspace sRGB "${RIZINDIR}/dist/osx/Resources/rizin-logo.png"
cd "${RIZINDIR}/dist/osx" && productbuild --resources Resources --distribution Distribution "rizin-${VERSION}.pkg"
mv "${RIZINDIR}/dist/osx/rizin-${VERSION}.pkg" "${RIZINDIR}/rizin-${VERSION}.pkg"
rm "${RIZINDIR}/dist/osx/rizin.pkg"
rm -rf "${OSXPKGDIR}"
rm -rf "${RIZININSTALL}"
rizin-0.7.4/dist/osx/Distribution 0000664 0001750 0001750 00000001363 14731035230 016376 0 ustar sophie sophie
Rizin
rizin.pkg
rizin-0.7.4/librz/ 0000775 0001750 0001750 00000000000 14731035230 013337 5 ustar sophie sophie rizin-0.7.4/librz/config/ 0000775 0001750 0001750 00000000000 14731035230 014604 5 ustar sophie sophie rizin-0.7.4/librz/config/meson.build 0000664 0001750 0001750 00000001253 14731035230 016747 0 ustar sophie sophie rz_config_sources = [
'config.c',
'hold.c',
'serialize_config.c'
]
rz_config = library('rz_config', rz_config_sources,
include_directories: [platform_inc],
dependencies: [
rz_util_dep
],
install: true,
implicit_include_directories: false,
install_rpath: rpath_lib,
soversion: rizin_libversion,
version: rizin_version,
name_suffix: lib_name_suffix,
name_prefix: lib_name_prefix,
)
rz_config_dep = declare_dependency(link_with: rz_config,
include_directories: [platform_inc])
meson.override_dependency('rz_config', rz_config_dep)
modules += { 'rz_config': {
'target': rz_config,
'dependencies': ['rz_util']
}}
rizin-0.7.4/librz/config/hold.c 0000664 0001750 0001750 00000007664 14731035230 015713 0 ustar sophie sophie // SPDX-FileCopyrightText: 2006-2021 pancake
// SPDX-License-Identifier: LGPL-3.0-only
#include
static void rz_config_hold_char_free(RzConfigHoldChar *hc) {
free(hc->key);
free(hc->value);
free(hc);
}
static void rz_config_hold_num_free(RzConfigHoldNum *hc) {
free(hc->key);
free(hc);
}
static int key_cmp_hold_s(const void *a, const void *b, void *user) {
const char *a_s = (const char *)a;
const RzConfigHoldChar *b_s = (const RzConfigHoldChar *)b;
return strcmp(a_s, b_s->key);
}
static int key_cmp_hold_i(const void *a, const void *b, void *user) {
const char *a_s = (const char *)a;
const RzConfigHoldNum *b_s = (const RzConfigHoldNum *)b;
return strcmp(a_s, b_s->key);
}
/**
* \brief Save the current values of a list of config options that have string values.
*
* Get the current values of a list of config variables (terminated by NULL) and
* save them in the RzConfigHold object \p h . \p rz_config_get is used to
* retrieve the current config values.
*
* \param h Reference to RzConfigHold instance
* \param ... List of config variables to save, terminated by NULL.
* \return true if at least one variable is correctly saved, false otherwise
*/
RZ_API bool rz_config_hold_s(RzConfigHold *h, ...) {
va_list ap;
char *key;
va_start(ap, h);
if (!h->list_char) {
h->list_char = rz_list_newf((RzListFree)rz_config_hold_char_free);
if (!h->list_char) {
va_end(ap);
return false;
}
}
while ((key = va_arg(ap, char *))) {
if (rz_list_find(h->list_char, key, key_cmp_hold_s, NULL)) {
continue;
}
const char *val = rz_config_get(h->cfg, key);
if (!val) {
continue;
}
RzConfigHoldChar *hc = RZ_NEW0(RzConfigHoldChar);
if (hc) {
hc->key = strdup(key);
hc->value = strdup(val);
rz_list_append(h->list_char, hc);
}
}
va_end(ap);
return true;
}
/**
* \brief Save the current values of a list of config options that have integer values.
*
* Get the current values of a list of config variables (terminated by NULL) and
* save them in the RzConfigHold object \p h . \p rz_config_get_i is used to
* retrieve the current config values.
*
* \param h Reference to RzConfigHold instance
* \param ... List of config variables to save, terminated by NULL.
* \return true if at least one variable is correctly saved, false otherwise
*/
RZ_API bool rz_config_hold_i(RzConfigHold *h, ...) {
va_list ap;
char *key;
if (!h) {
return false;
}
if (!h->list_num) {
h->list_num = rz_list_newf((RzListFree)rz_config_hold_num_free);
if (!h->list_num) {
return false;
}
}
va_start(ap, h);
while ((key = va_arg(ap, char *))) {
if (rz_list_find(h->list_num, key, key_cmp_hold_i, NULL)) {
continue;
}
RzConfigHoldNum *hc = RZ_NEW0(RzConfigHoldNum);
if (!hc) {
continue;
}
hc->key = strdup(key);
hc->value = rz_config_get_i(h->cfg, key);
rz_list_append(h->list_num, hc);
}
va_end(ap);
return true;
}
/**
* \brief Create an opaque object to save/restore some configuration options
*
* \param cfg RzConfig reference
* \return RzConfigHold allocated object
*/
RZ_API RzConfigHold *rz_config_hold_new(RzConfig *cfg) {
if (cfg) {
RzConfigHold *hold = RZ_NEW0(RzConfigHold);
if (hold) {
hold->cfg = cfg;
return hold;
}
}
return NULL;
}
/**
* \brief Restore whatever config options were previously saved in \p h
*
* \param h Reference to RzConfigHold
*/
RZ_API void rz_config_hold_restore(RzConfigHold *h) {
RzListIter *iter;
RzConfigHoldChar *hchar;
RzConfigHoldNum *hnum;
if (h) {
RzConfig *cfg = h->cfg;
rz_list_foreach (h->list_num, iter, hnum) {
(void)rz_config_set_i(cfg, hnum->key, hnum->value);
}
rz_list_foreach (h->list_char, iter, hchar) {
(void)rz_config_set(cfg, hchar->key, hchar->value);
}
}
}
/**
* \brief Free a RzConfigHold object \p h
*
* \param h Reference to RzConfigHold
*/
RZ_API void rz_config_hold_free(RzConfigHold *h) {
if (h) {
rz_list_free(h->list_num);
rz_list_free(h->list_char);
RZ_FREE(h);
}
}
rizin-0.7.4/librz/config/config.c 0000664 0001750 0001750 00000035436 14731035230 016230 0 ustar sophie sophie // SPDX-FileCopyrightText: 2006-2021 pancake
// SPDX-License-Identifier: LGPL-3.0-only
#include "rz_config.h"
RZ_API RZ_OWN RzConfigNode *rz_config_node_new(RZ_NONNULL const char *name, RZ_NONNULL const char *value) {
rz_return_val_if_fail(RZ_STR_ISNOTEMPTY(name) && value, NULL);
RzConfigNode *node = RZ_NEW0(RzConfigNode);
if (!node) {
return NULL;
}
node->name = strdup(name);
node->value = strdup(value);
node->flags = CN_RW | CN_STR;
node->i_value = rz_num_get(NULL, value);
node->options = rz_list_new();
return node;
}
RZ_API RZ_OWN RzConfigNode *rz_config_node_clone(RzConfigNode *n) {
rz_return_val_if_fail(n, NULL);
RzConfigNode *cn = RZ_NEW0(RzConfigNode);
if (!cn) {
return NULL;
}
cn->name = strdup(n->name);
cn->desc = n->desc ? strdup(n->desc) : NULL;
cn->value = strdup(n->value ? n->value : "");
cn->i_value = n->i_value;
cn->flags = n->flags;
cn->setter = n->setter;
cn->options = rz_list_clone(n->options);
return cn;
}
RZ_API void rz_config_node_free(RZ_NULLABLE void *n) {
RzConfigNode *node = (RzConfigNode *)n;
if (!node) {
return;
}
free(node->name);
free(node->desc);
free(node->value);
rz_list_free(node->options);
free(node);
}
RZ_API RZ_BORROW RzConfigNode *rz_config_node_get(RzConfig *cfg, RZ_NONNULL const char *name) {
rz_return_val_if_fail(cfg && RZ_STR_ISNOTEMPTY(name), NULL);
return ht_pp_find(cfg->ht, name, NULL);
}
RZ_API bool rz_config_set_getter(RzConfig *cfg, const char *key, RzConfigCallback cb) {
rz_return_val_if_fail(cfg && key, false);
RzConfigNode *node = rz_config_node_get(cfg, key);
if (node) {
node->getter = cb;
return true;
}
return false;
}
RZ_API bool rz_config_set_setter(RzConfig *cfg, const char *key, RzConfigCallback cb) {
RzConfigNode *node = rz_config_node_get(cfg, key);
if (node) {
node->setter = cb;
return true;
}
return false;
}
/**
* Returns the value of the config variable of \p name as a string
*/
RZ_API RZ_BORROW const char *rz_config_get(RzConfig *cfg, RZ_NONNULL const char *name) {
rz_return_val_if_fail(cfg && RZ_STR_ISNOTEMPTY(name), NULL);
RzConfigNode *node = rz_config_node_get(cfg, name);
if (node) {
if (node->getter) {
node->getter(cfg->user, node);
}
if (rz_config_node_is_bool(node)) {
return rz_str_bool(rz_str_is_true(node->value));
}
return node->value;
} else {
RZ_LOG_DEBUG("rz_config_get: variable '%s' not found\n", name);
}
return NULL;
}
/**
* Reads the value of the config variable of \p name only and only if
* the variable is boolean, then tries to write back the inverted value.
* Returns true in case of success.
*/
RZ_API bool rz_config_toggle(RzConfig *cfg, RZ_NONNULL const char *name) {
rz_return_val_if_fail(cfg && RZ_STR_ISNOTEMPTY(name), false);
RzConfigNode *node = rz_config_node_get(cfg, name);
if (!node) {
return false;
}
if (!rz_config_node_is_bool(node)) {
RZ_LOG_DEBUG("(error: '%s' is not a boolean variable)\n", name);
return false;
}
if (rz_config_node_is_ro(node)) {
RZ_LOG_DEBUG("(error: '%s' config key is read only)\n", name);
return false;
}
(void)rz_config_set_i(cfg, name, !node->i_value);
return true;
}
/**
* Reads the value of the config variable of \p name only and only if
* the variable is integer.
*/
RZ_API ut64 rz_config_get_i(RzConfig *cfg, RZ_NONNULL const char *name) {
rz_return_val_if_fail(cfg && RZ_STR_ISNOTEMPTY(name), 0);
RzConfigNode *node = rz_config_node_get(cfg, name);
if (node) {
if (node->getter) {
node->getter(cfg->user, node);
}
if (node->i_value || !strcmp(node->value, "false")) {
return node->i_value;
}
// TODO: Remove it once the switch to `rz_config_get_b()` is complete
if (!strcmp(node->value, "true")) {
return 1;
}
return (ut64)rz_num_math(cfg->num, node->value);
}
return (ut64)0LL;
}
/**
* Reads the value of the config variable of \p name only and only if
* the variable is boolean. Returns false in case of the failure.
*/
RZ_API bool rz_config_get_b(RzConfig *cfg, RZ_NONNULL const char *name) {
rz_return_val_if_fail(cfg && RZ_STR_ISNOTEMPTY(name), false);
RzConfigNode *node = rz_config_node_get(cfg, name);
if (!node) {
return false;
}
if (!rz_config_node_is_bool(node)) {
RZ_LOG_DEBUG("(error: '%s' is not a boolean variable)\n", name);
return false;
}
return rz_str_is_true(node->value);
}
RZ_API const char *rz_config_node_type(RzConfigNode *node) {
rz_return_val_if_fail(node, "");
if (rz_config_node_is_bool(node)) {
return "bool";
}
if (rz_config_node_is_str(node)) {
return "str";
}
if (rz_config_node_is_int(node)) {
if (!strncmp(node->value, "0x", 2)) {
return "addr";
}
return "int";
}
return "";
}
RZ_API RzConfigNode *rz_config_set_cb(RzConfig *cfg, const char *name, const char *value, RzConfigCallback cb) {
RzConfigNode *node = rz_config_set(cfg, name, value);
if (node && (node->setter = cb)) {
if (!cb(cfg->user, node)) {
return NULL;
}
}
return node;
}
RZ_API RzConfigNode *rz_config_set_i_cb(RzConfig *cfg, const char *name, int ivalue, RzConfigCallback cb) {
RzConfigNode *node = rz_config_set_i(cfg, name, ivalue);
if (node && (node->setter = cb)) {
if (!node->setter(cfg->user, node)) {
return NULL;
}
}
return node;
}
static bool __is_true_or_false(const char *s) {
return s && (!rz_str_casecmp(s, "true") || !rz_str_casecmp(s, "false"));
}
/**
* Writes the boolean \p value in the config variable of \p name only and only if
* the variable is boolean.
*/
RZ_API RzConfigNode *rz_config_set_b(RzConfig *cfg, RZ_NONNULL const char *name, bool value) {
rz_return_val_if_fail(cfg && cfg->ht, NULL);
rz_return_val_if_fail(RZ_STR_ISNOTEMPTY(name), NULL);
char *ov = NULL;
ut64 oi = 0;
RzConfigNode *node = rz_config_node_get(cfg, name);
if (node) {
if (rz_config_node_is_ro(node)) {
RZ_LOG_DEBUG("(error: '%s' config key is read only)\n", name);
return node;
}
oi = node->i_value;
if (node->value) {
ov = strdup(node->value);
}
if (rz_config_node_is_bool(node)) {
node->i_value = value ? 1 : 0;
char *svalue = strdup(rz_str_bool(value));
if (svalue) {
free(node->value);
node->value = svalue;
}
} else {
RZ_LOG_ERROR("(error: '%s' is not a boolean variable)\n", name);
free(ov);
return NULL;
}
} else {
if (!cfg->lock) {
node = rz_config_node_new(name, rz_str_bool(value));
if (!node) {
node = NULL;
goto beach;
}
node->flags = CN_RW | CN_BOOL;
node->i_value = value ? 1 : 0;
ht_pp_insert(cfg->ht, node->name, node);
if (cfg->nodes) {
rz_list_append(cfg->nodes, node);
}
} else {
RZ_LOG_ERROR("(locked: no new keys can be created (%s))\n", name);
}
}
if (node && node->setter) {
if (!node->setter(cfg->user, node)) {
if (oi != UT64_MAX) {
node->i_value = oi;
}
free(node->value);
node->value = strdup(ov ? ov : "");
}
}
beach:
free(ov);
return node;
}
/* TODO: reduce number of strdups here */
/**
* Writes the string \p value in the config variable of \p name.
*/
RZ_API RzConfigNode *rz_config_set(RzConfig *cfg, RZ_NONNULL const char *name, const char *value) {
rz_return_val_if_fail(cfg && cfg->ht, NULL);
rz_return_val_if_fail(RZ_STR_ISNOTEMPTY(name), NULL);
char *ov = NULL;
ut64 oi;
RzConfigNode *node = rz_config_node_get(cfg, name);
if (node) {
if (rz_config_node_is_ro(node)) {
eprintf("(error: '%s' config key is read only)\n", name);
return node;
}
oi = node->i_value;
if (node->value) {
ov = strdup(node->value);
if (!ov) {
goto beach;
}
} else {
free(node->value);
node->value = strdup("");
}
if (rz_config_node_is_bool(node)) {
bool b = rz_str_is_true(value);
node->i_value = b ? 1 : 0;
char *value = strdup(rz_str_bool(b));
if (value) {
free(node->value);
node->value = value;
}
} else {
if (!value) {
free(node->value);
node->value = strdup("");
node->i_value = 0;
} else {
if (node->value == value) {
goto beach;
}
free(node->value);
node->value = strdup(value);
if (IS_DIGIT(*value) || (value[0] == '-' && IS_DIGIT(value[1]))) {
if (strchr(value, '/')) {
node->i_value = rz_num_get(cfg->num, value);
} else {
node->i_value = rz_num_math(cfg->num, value);
}
} else {
node->i_value = 0;
}
node->flags |= CN_INT;
}
}
} else { // Create a new RzConfigNode
oi = UT64_MAX;
if (!cfg->lock) {
node = rz_config_node_new(name, value);
if (node) {
if (__is_true_or_false(value)) {
node->flags |= CN_BOOL;
node->i_value = rz_str_is_true(value) ? 1 : 0;
}
ht_pp_insert(cfg->ht, node->name, node);
rz_list_append(cfg->nodes, node);
} else {
eprintf("rz_config_set: unable to create a new RzConfigNode\n");
}
} else {
eprintf("rz_config_set: variable '%s' not found\n", name);
}
}
if (node && node->setter) {
if (!node->setter(cfg->user, node)) {
if (oi != UT64_MAX) {
node->i_value = oi;
}
free(node->value);
node->value = strdup(ov ? ov : "");
free(ov);
return NULL;
}
}
beach:
free(ov);
return node;
}
/**
* \brief Appends the given node to the config \p cfg.
*
* \param cfg The configuration the node is appended.
* \param node The node to append.
* \return bool True if the node was successful added. False otherwise.
*/
RZ_API bool rz_config_add_node(RZ_BORROW RzConfig *cfg, RZ_OWN RzConfigNode *node) {
rz_return_val_if_fail(cfg && node, false);
if (cfg->lock) {
RZ_LOG_WARN("Config locked. Plugin config node not copied.\n");
rz_config_node_free(node);
return false;
}
ht_pp_insert(cfg->ht, node->name, node);
rz_list_append(cfg->nodes, node);
return true;
}
/* rz_config_desc takes a RzConfig and a name,
* rz_config_node_desc takes a RzConfigNode
* Both set and return node->desc */
RZ_API const char *rz_config_desc(RzConfig *cfg, RZ_NONNULL const char *name, RZ_NULLABLE const char *desc) {
rz_return_val_if_fail(RZ_STR_ISNOTEMPTY(name), NULL);
RzConfigNode *node = rz_config_node_get(cfg, name);
return rz_config_node_desc(node, desc);
}
RZ_API const char *rz_config_node_desc(RzConfigNode *node, RZ_NULLABLE const char *desc) {
rz_return_val_if_fail(node, NULL);
if (desc) {
free(node->desc);
node->desc = strdup(desc);
}
return node->desc;
}
RZ_API bool rz_config_rm(RzConfig *cfg, RZ_NONNULL const char *name) {
rz_return_val_if_fail(RZ_STR_ISNOTEMPTY(name) && cfg, false);
RzConfigNode *node = rz_config_node_get(cfg, name);
if (node) {
ht_pp_delete(cfg->ht, node->name);
rz_list_delete_data(cfg->nodes, node);
return true;
}
return false;
}
RZ_API void rz_config_node_value_format_i(char *buf, size_t buf_size, const ut64 i, RZ_NULLABLE RzConfigNode *node) {
if (node && rz_config_node_is_bool(node)) {
rz_str_ncpy(buf, rz_str_bool((int)i), buf_size);
return;
}
if (i < 1024) {
snprintf(buf, buf_size, "%" PFMT64d "", i);
} else {
snprintf(buf, buf_size, "0x%08" PFMT64x "", i);
}
}
/**
* Writes the integer \p value in the config variable of \p name only and only if
* the variable is integer.
*/
RZ_API RzConfigNode *rz_config_set_i(RzConfig *cfg, RZ_NONNULL const char *name, const ut64 i) {
char buf[128], *ov = NULL;
rz_return_val_if_fail(cfg && name, NULL);
RzConfigNode *node = rz_config_node_get(cfg, name);
if (node) {
if (rz_config_node_is_ro(node)) {
node = NULL;
goto beach;
}
if (node->value) {
ov = strdup(node->value);
}
rz_config_node_value_format_i(buf, sizeof(buf), i, NULL);
free(node->value);
node->value = strdup(buf);
if (!node->value) {
node = NULL;
goto beach;
}
node->i_value = i;
} else {
if (!cfg->lock) {
rz_config_node_value_format_i(buf, sizeof(buf), i, NULL);
node = rz_config_node_new(name, buf);
if (!node) {
node = NULL;
goto beach;
}
node->flags = CN_RW | CN_INT;
node->i_value = i;
ht_pp_insert(cfg->ht, node->name, node);
if (cfg->nodes) {
rz_list_append(cfg->nodes, node);
}
} else {
RZ_LOG_ERROR("(locked: no new keys can be created (%s))\n", name);
}
}
if (node && node->setter) {
ut64 oi = node->i_value;
int ret = node->setter(cfg->user, node);
if (!ret) {
node->i_value = oi;
free(node->value);
node->value = strdup(ov ? ov : "");
}
}
beach:
free(ov);
return node;
}
static int cmp(RzConfigNode *a, RzConfigNode *b, void *user) {
return strcmp(a->name, b->name);
}
RZ_API void rz_config_lock(RzConfig *cfg, int l) {
rz_list_sort(cfg->nodes, (RzListComparator)cmp, NULL);
cfg->lock = l;
}
RZ_API bool rz_config_readonly(RzConfig *cfg, const char *key) {
RzConfigNode *n = rz_config_node_get(cfg, key);
if (n) {
n->flags |= CN_RO;
return true;
}
return false;
}
RZ_API RzConfig *rz_config_new(void *user) {
RzConfig *cfg = RZ_NEW0(RzConfig);
if (!cfg) {
return NULL;
}
cfg->ht = ht_pp_new0();
cfg->nodes = rz_list_newf((RzListFree)rz_config_node_free);
if (!cfg->nodes) {
RZ_FREE(cfg);
return NULL;
}
cfg->user = user;
cfg->num = NULL;
cfg->lock = 0;
return cfg;
}
RZ_API RzConfig *rz_config_clone(RzConfig *cfg) {
RzListIter *iter;
RzConfigNode *node;
RzConfig *c = rz_config_new(cfg->user);
if (!c) {
return NULL;
}
rz_list_foreach (cfg->nodes, iter, node) {
RzConfigNode *nn = rz_config_node_clone(node);
ht_pp_insert(c->ht, node->name, nn);
rz_list_append(c->nodes, nn);
}
c->lock = cfg->lock;
return c;
}
RZ_API void rz_config_free(RzConfig *cfg) {
if (cfg) {
cfg->nodes->free = rz_config_node_free;
rz_list_free(cfg->nodes);
ht_pp_free(cfg->ht);
free(cfg);
}
}
RZ_API void rz_config_visual_hit_i(RzConfig *cfg, const char *name, int delta) {
RzConfigNode *node = rz_config_node_get(cfg, name);
if (node && rz_config_node_is_int(node)) {
(void)rz_config_set_i(cfg, name, rz_config_get_i(cfg, name) + delta);
}
}
RZ_API void rz_config_bump(RzConfig *cfg, const char *key) {
char *orig = strdup(rz_config_get(cfg, key));
if (orig) {
rz_config_set(cfg, key, orig);
free(orig);
}
}
RZ_API void rz_config_serialize(RZ_NONNULL RzConfig *config, RZ_NONNULL Sdb *db) {
RzListIter *iter;
RzConfigNode *node;
rz_list_foreach (config->nodes, iter, node) {
sdb_set(db, node->name, node->value, 0);
}
}
static bool load_config_cb(void *user, const char *k, const char *v) {
RzConfig *config = user;
RzConfigNode *node = rz_config_node_get(config, k);
if (node) {
rz_config_set(config, k, v);
}
return true;
}
RZ_API bool rz_config_unserialize(RZ_NONNULL RzConfig *config, RZ_NONNULL Sdb *db, RZ_NULLABLE char **err) {
sdb_foreach(db, load_config_cb, config);
return true;
}
/**
* \brief Sets the configuration variable and its value passed as argument
*
* \param cfg reference to RzConfig
* \param str reference the configuration variable string (eg, 'asm.arch=x86')
*/
RZ_API bool rz_config_eval(RZ_NONNULL RzConfig *cfg, RZ_NONNULL const char *str) {
rz_return_val_if_fail(str, false);
char *name = rz_str_trim_dup(str);
char *value = strchr(name, '=');
if (!value) {
free(name);
return false;
}
*value++ = 0;
rz_config_set(cfg, name, value);
free(name);
return true;
}
rizin-0.7.4/librz/config/README.md 0000664 0001750 0001750 00000000000 14731035230 016051 0 ustar sophie sophie rizin-0.7.4/librz/config/serialize_config.c 0000664 0001750 0001750 00000002677 14731035230 020300 0 ustar sophie sophie // SPDX-FileCopyrightText: 2020 Florian Märkl
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
/*
*
* RzConfig isn't completely serialized, only the values.
*
* SDB Format:
*
* /
* =
* ...
*
*/
RZ_API void rz_serialize_config_save(RZ_NONNULL Sdb *db, RZ_NONNULL RzConfig *config) {
RzListIter *iter;
RzConfigNode *node;
rz_list_foreach (config->nodes, iter, node) {
sdb_set(db, node->name, node->value, 0);
}
}
typedef struct load_config_ctx_t {
RzConfig *config;
HtPP *exclude;
} LoadConfigCtx;
static bool load_config_cb(void *user, const char *k, const char *v) {
LoadConfigCtx *ctx = user;
if (ctx->exclude && ht_pp_find_kv(ctx->exclude, k, NULL)) {
return true;
}
RzConfigNode *node = rz_config_node_get(ctx->config, k);
if (!node) {
return 1;
}
rz_config_set(ctx->config, k, v);
return 1;
}
/**
* @param exclude NULL-terminated array of keys to not load from the sdb.
*/
RZ_API bool rz_serialize_config_load(RZ_NONNULL Sdb *db, RZ_NONNULL RzConfig *config,
RZ_NULLABLE const char *const *exclude, RZ_NULLABLE RzSerializeResultInfo *res) {
LoadConfigCtx ctx = { config, NULL };
if (exclude) {
ctx.exclude = ht_pp_new0();
if (!ctx.exclude) {
return false;
}
for (; *exclude; exclude++) {
ht_pp_insert(ctx.exclude, *exclude, NULL);
}
}
sdb_foreach(db, load_config_cb, &ctx);
ht_pp_free(ctx.exclude);
return true;
}
rizin-0.7.4/librz/syscall/ 0000775 0001750 0001750 00000000000 14731035230 015011 5 ustar sophie sophie rizin-0.7.4/librz/syscall/meson.build 0000664 0001750 0001750 00000001231 14731035230 017150 0 ustar sophie sophie rz_syscall_sources = [
'syscall.c',
]
rz_syscall = library('rz_syscall', rz_syscall_sources,
include_directories: [platform_inc],
dependencies: [rz_util_dep],
install: true,
implicit_include_directories: false,
install_rpath: rpath_lib,
soversion: rizin_libversion,
version: rizin_version,
name_suffix: lib_name_suffix,
name_prefix: lib_name_prefix,
)
rz_syscall_dep = declare_dependency(link_with: rz_syscall,
include_directories: [platform_inc])
meson.override_dependency('rz_syscall', rz_syscall_dep)
modules += { 'rz_syscall': {
'target': rz_syscall,
'dependencies': ['rz_util']
}}
subdir('d')
rizin-0.7.4/librz/syscall/d/ 0000775 0001750 0001750 00000000000 14731035230 015234 5 ustar sophie sophie rizin-0.7.4/librz/syscall/d/ios-arm-32.sdb.txt 0000664 0001750 0001750 00000021417 14731035230 020342 0 ustar sophie sophie _=0x81
exit=0x81,1,1,
fork=0x81,2,0
read=0x81,3,3,
write=0x81,4,3,
open=0x81,5,3,
close=0x81,6,1,
wait4=0x81,7,3,
link=0x81,9,2,zz
unlink=0x81,10,1,z
chdir=0x81,12,1,z
fchdir=0x81,13,1,i
mknod=0x81,14,3,zii
chmod=0x81,15,2,zi
chown=0x81,16,3,zii
getfsstat=0x81,18,3,pii
getpid=0x81,20,0,
setuid=0x81,23,1,i
getuid=0x81,24,0,
geteuid=0x81,25,0,
ptrace=0x81,26,4,
recvmsg=0x81,27,3,
sendmsg=0x81,28,3,
recvfrom=0x81,29,3,
accept=0x81,30,1,i
getpeername=0x81,31,0,
getsockname=0x81,32,0,
access=0x81,33,0,
chflags=0x81,34,0
fchflags=0x81,35,0
sync=0x81,36,0
kill=0x81,37,0
getppid=0x81,39,0
dup=0x81,41,0
pipe=0x81,42,0
getegid=0x81,43,0
sigaction=0x81,46,0
getgid=0x81,47,0
sigprocmask=0x81,48,0
getlogin=0x81,49,0
setlogin=0x81,50,0
acct=0x81,51,0
sigpending=0x81,52,0
sigaltstack=0x81,53,0
ioctl=0x81,54,0
reboot=0x81,55,0
revoke=0x81,56,0
symlink=0x81,57,0
readlink=0x81,58,0
execve=0x81,59,0
umask=0x81,60,0
chroot=0x81,61,0
msync=0x81,65,0
vfork=0x81,66,0
munmap=0x81,73,0
mprotect=0x81,74,0
madvise=0x81,75,0
mincore=0x81,78,0
getgroups=0x81,79,0
setgroups=0x81,80,0
getpgrp=0x81,81,0
setpgid=0x81,82,0
setitimer=0x81,83,0
swapon=0x81,85,0
getitimer=0x81,86,0
getdtablesize=0x81,89,0
dup2=0x81,90,0
fcntl=0x81,92,0
select=0x81,93,0
fsync=0x81,95,0
setpriority=0x81,96,0
socket=0x81,97,0
connect=0x81,98,0
getpriority=0x81,100,0
bind=0x81,104,0
setsockopt=0x81,105,0
listen=0x81,106,0
sigsuspend=0x81,111,0
gettimeofday=0x81,116,0
getrusage=0x81,117,0
getsockopt=0x81,118,0
readv=0x81,120,0
writev=0x81,121,0
settimeofday=0x81,122,0
fchown=0x81,123,0
fchmod=0x81,124,0
setreuid=0x81,126,0
setregid=0x81,127,0
rename=0x81,128,0
flock=0x81,131,0
mkfifo=0x81,132,0
sendto=0x81,133,0
shutdown=0x81,134,0
socketpair=0x81,135,0
mkdir=0x81,136,0
rmdir=0x81,137,0
utimes=0x81,138,0
futimes=0x81,139,0
adjtime=0x81,140,0
gethostuuid=0x81,142,0
setsid=0x81,147,0
getpgid=0x81,151,0
setprivexec=0x81,152,0
pread=0x81,153,0
pwrite=0x81,154,0
statfs=0x81,157,0
fstatfs=0x81,158,0
unmount=0x81,159,0
quotactl=0x81,165,0
mount=0x81,167,0
csops=0x81,169,0
170=0x81,170,0
waitid=0x81,173,0
kdebug_trace=0x81,180,0
setgid=0x81,181,0
setegid=0x81,182,0
seteuid=0x81,183,0
sigreturn=0x81,184,0
chud=0x81,185,0
fdatasync=0x81,187,0
stat=0x81,188,0
fstat=0x81,189,0
lstat=0x81,190,0
pathconf=0x81,191,0
fpathconf=0x81,192,0
getrlimit=0x81,194,0
setrlimit=0x81,195,0
getdirentries=0x81,196,0
mmap=0x81,197,0
lseek=0x81,199,0
truncate=0x81,200,0
ftruncate=0x81,201,0
__sysctl=0x81,202,0
mlock=0x81,203,0
munlock=0x81,204,0
undelete=0x81,205,0
mkcomplex=0x81,216,0
getattrlist=0x81,220,0
setattrlist=0x81,221,0
getdirentriesattr=0x81,222,0
exchangedata=0x81,223,0
searchfs=0x81,225,0
delete=0x81,226,0
copyfile=0x81,227,0
fgetattrlist=0x81,228,0
fsetattrlist=0x81,229,0
poll=0x81,230,0
watchevent=0x81,231,0
waitevent=0x81,232,0
modwatch=0x81,233,0
getxattr=0x81,234,0
fgetxattr=0x81,235,0
setxattr=0x81,236,0
fsetxattr=0x81,237,0
removexattr=0x81,238,0
fremovexattr=0x81,239,0
listxattr=0x81,240,0
flistxattr=0x81,241,0
fsctl=0x81,242,0
initgroups=0x81,243,0
posix_spawn=0x81,244,0
ffsctl=0x81,245,0
minherit=0x81,250,0
shm_open=0x81,266,0
shm_unlink=0x81,267,0
sem_open=0x81,268,0
sem_close=0x81,269,0
sem_unlink=0x81,270,0
sem_wait=0x81,271,0
sem_trywait=0x81,272,0
sem_post=0x81,273,0
sem_getvalue=0x81,274,0
sem_init=0x81,275,0
sem_destroy=0x81,276,0
open_extended=0x81,277,0
umask_extended=0x81,278,0
stat_extended=0x81,279,0
lstat_extended=0x81,280,0
fstat_extended=0x81,281,0
chmod_extended=0x81,282,0
fchmod_extended=0x81,283,0
access_extended=0x81,284,0
settid=0x81,285,0
gettid=0x81,286,0
setsgroups=0x81,287,0
getsgroups=0x81,288,0
setwgroups=0x81,289,0
getwgroups=0x81,290,0
mkfifo_extended=0x81,291,0
mkdir_extended=0x81,292,0
shared_region_check_np=0x81,294,0
vm_pressure_monitor=0x81,296,0
psynch_rw_longrdlock=0x81,297,0
psynch_rw_yieldwrlock=0x81,298,0
psynch_rw_downgrade=0x81,299,0
psynch_rw_upgrade=0x81,300,0
psynch_mutexwait=0x81,301,0
psynch_mutexdrop=0x81,302,0
psynch_cvbroad=0x81,303,0
psynch_cvsignal=0x81,304,0
psynch_cvwait=0x81,305,0
psynch_rw_rdlock=0x81,306,0
psynch_rw_wrlock=0x81,307,0
psynch_rw_unlock=0x81,308,0
psynch_rw_unlock2=0x81,309,0
getsid=0x81,310,0
settid_with_pid=0x81,311,0
psynch_cvclrprepost=0x81,312,0
aio_fsync=0x81,313,0
aio_return=0x81,314,0
aio_suspend=0x81,315,0
aio_cancel=0x81,316,0
aio_error=0x81,317,0
aio_read=0x81,318,0
aio_write=0x81,319,0
lio_listio=0x81,320,0
iopolicysys=0x81,322,0
process_policy=0x81,323,0
mlockall=0x81,324,0
munlockall=0x81,325,0
issetugid=0x81,327,0
__pthread_kill=0x81,328,0
__pthread_sigmask=0x81,329,0
__sigwait=0x81,330,0
__disable_threadsignal=0x81,331,0
__pthread_markcancel=0x81,332,0
__pthread_canceled=0x81,333,0
__semwait_signal=0x81,334,0
proc_info=0x81,336,0
stat64=0x81,338,0
fstat64=0x81,339,0
lstat64=0x81,340,0
stat64_extended=0x81,341,0
lstat64_extended=0x81,342,0
fstat64_extended=0x81,343,0
getdirentries64=0x81,344,0
statfs64=0x81,345,0
fstatfs64=0x81,346,0
getfsstat64=0x81,347,0
__pthread_chdir=0x81,348,0
__pthread_fchdir=0x81,349,0
audit=0x81,350,0
auditon=0x81,351,0
getauid=0x81,353,0
setauid=0x81,354,0
getaudit_addr=0x81,357,0
setaudit_addr=0x81,358,0
auditctl=0x81,359,0
bsdthread_create=0x81,360,0
bsdthread_terminate=0x81,361,0
kqueue=0x81,362,0
kevent=0x81,363,0
lchown=0x81,364,0
stack_snapshot=0x81,365,0
bsdthread_register=0x81,366,0
workq_open=0x81,367,0
workq_kernreturn=0x81,368,0
kevent64=0x81,369,7,
__old_semwait_signal=0x81,370,0
__old_semwait_signal_nocancel=0x81,371,0
thread_selfid=0x81,372,0
ledger=0x81,373,0
__mac_execve=0x81,380,0
__mac_syscall=0x81,381,0
__mac_get_file=0x81,382,0
__mac_set_file=0x81,383,0
__mac_get_link=0x81,384,0
__mac_set_link=0x81,385,0
__mac_get_proc=0x81,386,0
__mac_set_proc=0x81,387,0
__mac_get_fd=0x81,388,0
__mac_set_fd=0x81,389,0
__mac_get_pid=0x81,390,0
__mac_get_lcid=0x81,391,0
__mac_get_lctx=0x81,392,0
__mac_set_lctx=0x81,393,0
setlcid=0x81,394,0
getlcid=0x81,395,0
read_nocancel=0x81,396,0
write_nocancel=0x81,397,0
open_nocancel=0x81,398,0
close_nocancel=0x81,399,0
wait4_nocancel=0x81,400,0
recvmsg_nocancel=0x81,401,0
sendmsg_nocancel=0x81,402,0
recvfrom_nocancel=0x81,403,0
accept_nocancel=0x81,404,0
msync_nocancel=0x81,405,0
fcntl_nocancel=0x81,406,0
select_nocancel=0x81,407,0
fsync_nocancel=0x81,408,0
connect_nocancel=0x81,409,0
sigsuspend_nocancel=0x81,410,0
readv_nocancel=0x81,411,0
writev_nocancel=0x81,412,0
sendto_nocancel=0x81,413,0
pread_nocancel=0x81,414,0
pwrite_nocancel=0x81,415,0
waitid_nocancel=0x81,416,0
poll_nocancel=0x81,417,0
sem_wait_nocancel=0x81,420,0
aio_suspend_nocancel=0x81,421,0
__sigwait_nocancel=0x81,422,0
__semwait_signal_nocancel=0x81,423,0
__mac_mount=0x81,424,0
__mac_get_mount=0x81,425,0
__mac_getfsstat=0x81,426,0
fsgetpath=0x81,427,0
audit_session_self=0x81,428,0
audit_session_join=0x81,429,0
fileport_makeport=0x81,430,0
fileport_makefd=0x81,431,0
audit_session_port=0x81,432,0
pid_suspend=0x81,433,0
pid_resume=0x81,434,0
pid_hibernate=0x81,435,0
pid_shutdown_sockets=0x81,436,0
shared_region_map_and_slide_np=0x81,438,0
kas_info=0x81,439,0
memorystatus_control=0x81,440,0
guarded_open_np=0x81,441,0
guarded_close_np=0x81,442,0
guarded_kqueue_np=0x81,443,0
change_fdguard_np=0x81,444,0
old __proc_suppress=0x81,445,0
proc_rlimit_control=0x81,446,0
proc_connectx=0x81,447,0
proc_disconnectx=0x81,448,0
proc_peeloff=0x81,449,0
proc_socket_delegate=0x81,450,0
proc_telemetry=0x81,451,0
proc_uuid_policy=0x81,452,0
memorystatus_get_level=0x81,453,0
system_override=0x81,454,0
vfs_purge=0x81,455,0
sfi_ctl=0x81,456,0
sfi_pidctl=0x81,457,0
coalition=0x81,458,0
coalition_info=0x81,459,0
necp_match_policy=0x81,460,0
getattrlistbulk=0x81,461,0
placeholder for clonefile=0x81,462,0
openat=0x81,463,0
openat_nocancel=0x81,464,0
renameat=0x81,465,0
faccessat=0x81,466,0
fchmodat=0x81,467,0
fchownat=0x81,468,0
fstatat=0x81,469,0
fstatat64=0x81,470,0
linkat=0x81,471,0
unlinkat=0x81,472,0
readlinkat=0x81,473,0
symlinkat=0x81,474,0
mkdirat=0x81,475,0
getattrlistat=0x81,476,0
proc_trace_log=0x81,477,0
bsdthread_ctl=0x81,478,0
openbyid_np=0x81,479,0
recvmsg_x=0x81,480,0
sendmsg_x=0x81,481,0
thread_selfusage=0x81,482,0
guarded_open_dprotected_np=0x81,484,0
guarded_write_np=0x81,485,0
guarded_pwrite_np=0x81,486,0
guarded_writev_np=0x81,487,0
rename_ext=0x81,488,0
mremap_encrypted=0x81,489,0
netagent_trigger=0x81,490,0
stack_snapshot_with_config=0x81,491,0
microstackshot=0x81,492,0
grab_pgo_data=0x81,493,0
persona=0x81,494,0
work_interval_ctl=0x81,499,0
getentropy=0x81,500,0
necp_open=0x81,501,0
necp_client_action=0x81,502,0
__nexus_open=0x81,503,0
__nexus_register=0x81,504,0
__nexus_deregister=0x81,505,0
__nexus_create=0x81,506,0
__nexus_destroy=0x81,507,0
__nexus_get_opt=0x81,508,0
__nexus_set_opt=0x81,509,0
__channel_open=0x81,510,0
__channel_get_info=0x81,511,0
__channel_sync=0x81,512,0
__channel_get_opt=0x81,513,0
__channel_set_opt=0x81,514,0
ulock_wait=0x81,515,0
ulock_wake=0x81,516,0
fclonefileat=0x81,517,0
fs_snapshot=0x81,518,0
terminate_with_payload=0x81,520,0
rizin-0.7.4/librz/syscall/d/windows-x86-32.sdb.txt 0000664 0001750 0001750 00000131201 14731035230 021101 0 ustar sophie sophie NtAcceptConnectPort=0x2e,0x0000,6,
NtAccessCheck=0x2e,0x0001,8,
NtAccessCheckAndAuditAlarm=0x2e,0x0002,11,
NtAccessCheckByType=0x2e,0x0003,11,
NtAccessCheckByTypeAndAuditAlarm=0x2e,0x0004,16,
NtAccessCheckByTypeResultList=0x2e,0x0005,11,
NtAccessCheckByTypeResultListAndAuditAlarm=0x2e,0x0006,16,
NtAccessCheckByTypeResultListAndAuditAlarmByPlugin=0x2e,0x0007,17,
NtAddAtom=0x2e,0x0008,3,
NtAddBootEntry=0x2e,0x0009,2,
NtAddDriverEntry=0x2e,0x000a,2,
NtAdjustGroupsToken=0x2e,0x000b,6,
NtAdjustPrivilegesToken=0x2e,0x000c,6,
NtAlertResumeThread=0x2e,0x000d,2,
NtAlertThread=0x2e,0x000e,1,
NtAllocateLocallyUniqueId=0x2e,0x000f,1,
NtAllocateReserveObject=0x2e,0x0010,3,
NtAllocateUserPhysicalPages=0x2e,0x0011,3,
NtAllocateUuids=0x2e,0x0012,4,
NtAllocateVirtualMemory=0x2e,0x0013,6,
NtAlpcAcceptConnectPort=0x2e,0x0014,9,
NtAlpcCancelMessage=0x2e,0x0015,3,
NtAlpcConnectPort=0x2e,0x0016,11,
NtAlpcCreatePort=0x2e,0x0017,3,
NtAlpcCreatePortSection=0x2e,0x0018,6,
NtAlpcCreateResourceReserve=0x2e,0x0019,4,
NtAlpcCreateSectionView=0x2e,0x001a,3,
NtAlpcCreateSecurityContext=0x2e,0x001b,3,
NtAlpcDeletePortSection=0x2e,0x001c,3,
NtAlpcDeleteResourceReserve=0x2e,0x001d,3,
NtAlpcDeleteSectionView=0x2e,0x001e,3,
NtAlpcDeleteSecurityContext=0x2e,0x001f,3,
NtAlpcDisconnectPort=0x2e,0x0020,2,
NtAlpcImpersonateClientOfPort=0x2e,0x0021,3,
NtAlpcOpenSenderProcess=0x2e,0x0022,6,
NtAlpcOpenSenderThread=0x2e,0x0023,6,
NtAlpcQueryInformation=0x2e,0x0024,5,
NtAlpcQueryInformationMessage=0x2e,0x0025,6,
NtAlpcRevokeSecurityContext=0x2e,0x0026,3,
NtAlpcSendWaitReceivePort=0x2e,0x0027,8,
NtAlpcSetInformation=0x2e,0x0028,4,
NtApphelpCacheControl=0x2e,0x0029,2,
NtAreMappedFilesTheSame=0x2e,0x002a,2,
NtAssignProcessToJobObject=0x2e,0x002b,2,
NtCallbackReturn=0x2e,0x002c,3,
NtCancelIoFile=0x2e,0x002d,2,
NtCancelIoFileEx=0x2e,0x002e,3,
NtCancelSynchronousIoFile=0x2e,0x002f,3,
NtCancelTimer=0x2e,0x0030,2,
NtClearEvent=0x2e,0x0031,1,
NtClose=0x2e,0x0032,1,
NtCloseObjectAuditAlarm=0x2e,0x0033,3,
NtCommitComplete=0x2e,0x0034,2,
NtCommitEnlistment=0x2e,0x0035,2,
NtCommitTransaction=0x2e,0x0036,2,
NtCompactKeys=0x2e,0x0037,2,
NtCompareTokens=0x2e,0x0038,3,
NtCompleteConnectPort=0x2e,0x0039,1,
NtCompressKey=0x2e,0x003a,1,
NtConnectPort=0x2e,0x003b,8,
NtContinue=0x2e,0x003c,2,
NtCreateDebugObject=0x2e,0x003d,4,
NtCreateDirectoryObject=0x2e,0x003e,3,
NtCreateEnlistment=0x2e,0x003f,8,
NtCreateEvent=0x2e,0x0040,5,
NtCreateEventPair=0x2e,0x0041,3,
NtCreateFile=0x2e,0x0042,11,
NtCreateIoCompletion=0x2e,0x0043,4,
NtCreateJobObject=0x2e,0x0044,3,
NtCreateJobSet=0x2e,0x0045,3,
NtCreateKey=0x2e,0x0046,7,
NtCreateKeyedEvent=0x2e,0x0047,4,
NtCreateKeyTransacted=0x2e,0x0048,8,
NtCreateMailslotFile=0x2e,0x0049,8,
NtCreateMutant=0x2e,0x004a,4,
NtCreateNamedPipeFile=0x2e,0x004b,14,
NtCreatePagingFile=0x2e,0x004c,4,
NtCreatePort=0x2e,0x004d,5,
NtCreatePrivateNamespace=0x2e,0x004e,4,
NtCreateProcess=0x2e,0x004f,8,
NtCreateProcessEx=0x2e,0x0050,9,
NtCreateProfile=0x2e,0x0051,9,
NtCreateProfileEx=0x2e,0x0052,10,
NtCreateResourceManager=0x2e,0x0053,7,
NtCreateSection=0x2e,0x0054,7,
NtCreateSemaphore=0x2e,0x0055,5,
NtCreateSymbolicLinkObject=0x2e,0x0056,4,
NtCreateThread=0x2e,0x0057,8,
NtCreateThreadEx=0x2e,0x0058,11,
NtCreateTimer=0x2e,0x0059,4,
NtCreateToken=0x2e,0x005a,13,
NtCreateTransaction=0x2e,0x005b,10,
NtCreateTransactionManager=0x2e,0x005c,6,
NtCreateUserProcess=0x2e,0x005d,11,
NtCreateWaitablePort=0x2e,0x005e,5,
NtCreateWorkerFactory=0x2e,0x005f,10,
NtDebugActiveProcess=0x2e,0x0060,2,
NtDebugContinue=0x2e,0x0061,3,
NtDelayExecution=0x2e,0x0062,2,
NtDeleteAtom=0x2e,0x0063,1,
NtDeleteBootEntry=0x2e,0x0064,1,
NtDeleteDriverEntry=0x2e,0x0065,1,
NtDeleteFile=0x2e,0x0066,1,
NtDeleteKey=0x2e,0x0067,1,
NtDeleteObjectAuditAlarm=0x2e,0x0068,3,
NtDeletePrivateNamespace=0x2e,0x0069,1,
NtDeleteValueKey=0x2e,0x006a,2,
NtDeviceIoControlFile=0x2e,0x006b,10,
NtDisableLastKnownGood=0x2e,0x006c,0,
NtDisplayString=0x2e,0x006d,1,
NtDrawText=0x2e,0x006e,1,
NtDuplicateObject=0x2e,0x006f,7,
NtDuplicateToken=0x2e,0x0070,6,
NtEnableLastKnownGood=0x2e,0x0071,0,
NtEnumerateBootEntries=0x2e,0x0072,2,
NtEnumerateDriverEntries=0x2e,0x0073,2,
NtEnumerateKey=0x2e,0x0074,6,
NtEnumerateSystemEnvironmentValuesEx=0x2e,0x0075,3,
NtEnumerateTransactionObject=0x2e,0x0076,5,
NtEnumerateValueKey=0x2e,0x0077,6,
NtExtendSection=0x2e,0x0078,2,
NtFilterToken=0x2e,0x0079,6,
NtFindAtom=0x2e,0x007a,3,
NtFlushBuffersFile=0x2e,0x007b,2,
NtFlushInstallUILanguage=0x2e,0x007c,2,
NtFlushInstructionCache=0x2e,0x007d,3,
NtFlushKey=0x2e,0x007e,1,
NtFlushProcessWriteBuffers=0x2e,0x007f,0,
NtFlushVirtualMemory=0x2e,0x0080,4,
NtFlushWriteBuffer=0x2e,0x0081,0,
NtFreeUserPhysicalPages=0x2e,0x0082,3,
NtFreeVirtualMemory=0x2e,0x0083,4,
NtFreezeRegistry=0x2e,0x0084,1,
NtFreezeTransactions=0x2e,0x0085,2,
NtFsControlFile=0x2e,0x0086,10,
NtGetContextThread=0x2e,0x0087,2,
NtGetCurrentProcessorNumber=0x2e,0x0088,0,
NtGetDevicePowerState=0x2e,0x0089,2,
NtGetMUIRegistryInfo=0x2e,0x008a,3,
NtGetNextProcess=0x2e,0x008b,5,
NtGetNextThread=0x2e,0x008c,6,
NtGetNlsSectionPtr=0x2e,0x008d,5,
NtGetNotificationResourceManager=0x2e,0x008e,7,
NtGetPlugPlayEvent=0x2e,0x008f,4,
NtGetWriteWatch=0x2e,0x0090,7,
NtImpersonateAnonymousToken=0x2e,0x0091,1,
NtImpersonateClientOfPort=0x2e,0x0092,2,
NtImpersonateThread=0x2e,0x0093,3,
NtInitializeNlsFiles=0x2e,0x0094,3,
NtInitializeRegistry=0x2e,0x0095,1,
NtInitiatePowerAction=0x2e,0x0096,4,
NtIsProcessInJob=0x2e,0x0097,2,
NtIsSystemResumeAutomatic=0x2e,0x0098,0,
NtIsUILanguageComitted=0x2e,0x0099,0,
NtListenPort=0x2e,0x009a,2,
NtLoadDriver=0x2e,0x009b,1,
NtLoadKey=0x2e,0x009c,2,
NtLoadKey2=0x2e,0x009d,3,
NtLoadKeyEx=0x2e,0x009e,8,
NtLockFile=0x2e,0x009f,10,
NtLockProductActivationKeys=0x2e,0x00a0,2,
NtLockRegistryKey=0x2e,0x00a1,1,
NtLockVirtualMemory=0x2e,0x00a2,4,
NtMakePermanentObject=0x2e,0x00a3,1,
NtMakeTemporaryObject=0x2e,0x00a4,1,
NtMapCMFModule=0x2e,0x00a5,6,
NtMapUserPhysicalPages=0x2e,0x00a6,3,
NtMapUserPhysicalPagesScatter=0x2e,0x00a7,3,
NtMapViewOfSection=0x2e,0x00a8,10,
NtModifyBootEntry=0x2e,0x00a9,1,
NtModifyDriverEntry=0x2e,0x00aa,1,
NtNotifyChangeDirectoryFile=0x2e,0x00ab,9,
NtNotifyChangeKey=0x2e,0x00ac,10,
NtNotifyChangeMultipleKeys=0x2e,0x00ad,12,
NtNotifyChangeSession=0x2e,0x00ae,8,
NtOpenDirectoryObject=0x2e,0x00af,3,
NtOpenEnlistment=0x2e,0x00b0,5,
NtOpenEvent=0x2e,0x00b1,3,
NtOpenEventPair=0x2e,0x00b2,3,
NtOpenFile=0x2e,0x00b3,6,
NtOpenIoCompletion=0x2e,0x00b4,3,
NtOpenJobObject=0x2e,0x00b5,3,
NtOpenKey=0x2e,0x00b6,3,
NtOpenKeyEx=0x2e,0x00b7,4,
NtOpenKeyedEvent=0x2e,0x00b8,3,
NtOpenKeyTransacted=0x2e,0x00b9,4,
NtOpenKeyTransactedEx=0x2e,0x00ba,5,
NtOpenMutant=0x2e,0x00bb,3,
NtOpenObjectAuditAlarm=0x2e,0x00bc,12,
NtOpenPrivateNamespace=0x2e,0x00bd,4,
NtOpenProcess=0x2e,0x00be,4,
NtOpenProcessToken=0x2e,0x00bf,3,
NtOpenProcessTokenEx=0x2e,0x00c0,4,
NtOpenResourceManager=0x2e,0x00c1,5,
NtOpenSection=0x2e,0x00c2,3,
NtOpenSemaphore=0x2e,0x00c3,3,
NtOpenSession=0x2e,0x00c4,3,
NtOpenSymbolicLinkObject=0x2e,0x00c5,3,
NtOpenThread=0x2e,0x00c6,4,
NtOpenThreadToken=0x2e,0x00c7,4,
NtOpenThreadTokenEx=0x2e,0x00c8,5,
NtOpenTimer=0x2e,0x00c9,3,
NtOpenTransaction=0x2e,0x00ca,5,
NtOpenTransactionManager=0x2e,0x00cb,6,
NtPlugPlayControl=0x2e,0x00cc,3,
NtPowerInformation=0x2e,0x00cd,5,
NtPrepareComplete=0x2e,0x00ce,2,
NtPrepareEnlistment=0x2e,0x00cf,2,
NtPrePrepareComplete=0x2e,0x00d0,2,
NtPrePrepareEnlistment=0x2e,0x00d1,2,
NtPrivilegeCheck=0x2e,0x00d2,3,
NtPrivilegedServiceAuditAlarm=0x2e,0x00d3,5,
NtPrivilegeObjectAuditAlarm=0x2e,0x00d4,6,
NtPropagationComplete=0x2e,0x00d5,4,
NtPropagationFailed=0x2e,0x00d6,3,
NtProtectVirtualMemory=0x2e,0x00d7,5,
NtPulseEvent=0x2e,0x00d8,2,
NtQueryAttributesFile=0x2e,0x00d9,2,
NtQueryBootEntryOrder=0x2e,0x00da,2,
NtQueryBootOptions=0x2e,0x00db,2,
NtQueryDebugFilterState=0x2e,0x00dc,2,
NtQueryDefaultLocale=0x2e,0x00dd,2,
NtQueryDefaultUILanguage=0x2e,0x00de,1,
NtQueryDirectoryFile=0x2e,0x00df,11,
NtQueryDirectoryObject=0x2e,0x00e0,7,
NtQueryDriverEntryOrder=0x2e,0x00e1,2,
NtQueryEaFile=0x2e,0x00e2,9,
NtQueryEvent=0x2e,0x00e3,5,
NtQueryFullAttributesFile=0x2e,0x00e4,2,
NtQueryInformationAtom=0x2e,0x00e5,5,
NtQueryInformationEnlistment=0x2e,0x00e6,5,
NtQueryInformationFile=0x2e,0x00e7,5,
NtQueryInformationJobObject=0x2e,0x00e8,5,
NtQueryInformationPort=0x2e,0x00e9,5,
NtQueryInformationProcess=0x2e,0x00ea,5,
NtQueryInformationResourceManager=0x2e,0x00eb,5,
NtQueryInformationThread=0x2e,0x00ec,5,
NtQueryInformationToken=0x2e,0x00ed,5,
NtQueryInformationTransaction=0x2e,0x00ee,5,
NtQueryInformationTransactionManager=0x2e,0x00ef,5,
NtQueryInformationWorkerFactory=0x2e,0x00f0,5,
NtQueryInstallUILanguage=0x2e,0x00f1,1,
NtQueryIntervalProfile=0x2e,0x00f2,2,
NtQueryIoCompletion=0x2e,0x00f3,5,
NtQueryKey=0x2e,0x00f4,5,
NtQueryLicenseValue=0x2e,0x00f5,5,
NtQueryMultipleValueKey=0x2e,0x00f6,6,
NtQueryMutant=0x2e,0x00f7,5,
NtQueryObject=0x2e,0x00f8,5,
NtQueryOpenSubKeys=0x2e,0x00f9,2,
NtQueryOpenSubKeysEx=0x2e,0x00fa,4,
NtQueryPerformanceCounter=0x2e,0x00fb,2,
NtQueryPortInformationProcess=0x2e,0x00fc,0,
NtQueryQuotaInformationFile=0x2e,0x00fd,9,
NtQuerySection=0x2e,0x00fe,5,
NtQuerySecurityAttributesToken=0x2e,0x00ff,6,
NtQuerySecurityObject=0x2e,0x0100,5,
NtQuerySemaphore=0x2e,0x0101,5,
NtQuerySymbolicLinkObject=0x2e,0x0102,3,
NtQuerySystemEnvironmentValue=0x2e,0x0103,4,
NtQuerySystemEnvironmentValueEx=0x2e,0x0104,5,
NtQuerySystemInformation=0x2e,0x0105,4,
NtQuerySystemInformationEx=0x2e,0x0106,6,
NtQuerySystemTime=0x2e,0x0107,1,
NtQueryTimer=0x2e,0x0108,5,
NtQueryTimerResolution=0x2e,0x0109,3,
NtQueryValueKey=0x2e,0x010a,6,
NtQueryVirtualMemory=0x2e,0x010b,6,
NtQueryVolumeInformationFile=0x2e,0x010c,5,
NtQueueApcThread=0x2e,0x010d,5,
NtQueueApcThreadEx=0x2e,0x010e,6,
NtRaiseException=0x2e,0x010f,3,
NtRaiseHardError=0x2e,0x0110,6,
NtReadFile=0x2e,0x0111,9,
NtReadFileScatter=0x2e,0x0112,9,
NtReadOnlyEnlistment=0x2e,0x0113,2,
NtReadRequestData=0x2e,0x0114,6,
NtReadVirtualMemory=0x2e,0x0115,5,
NtRecoverEnlistment=0x2e,0x0116,2,
NtRecoverResourceManager=0x2e,0x0117,1,
NtRecoverTransactionManager=0x2e,0x0118,1,
NtRegisterProtocolAddressInformation=0x2e,0x0119,5,
NtRegisterThreadTerminatePort=0x2e,0x011a,1,
NtReleaseKeyedEvent=0x2e,0x011b,4,
NtReleaseMutant=0x2e,0x011c,2,
NtReleaseSemaphore=0x2e,0x011d,3,
NtReleaseWorkerFactoryWorker=0x2e,0x011e,1,
NtRemoveIoCompletion=0x2e,0x011f,5,
NtRemoveIoCompletionEx=0x2e,0x0120,6,
NtRemoveProcessDebug=0x2e,0x0121,2,
NtRenameKey=0x2e,0x0122,2,
NtRenameTransactionManager=0x2e,0x0123,2,
NtReplaceKey=0x2e,0x0124,3,
NtReplacePartitionUnit=0x2e,0x0125,3,
NtReplyPort=0x2e,0x0126,2,
NtReplyWaitReceivePort=0x2e,0x0127,4,
NtReplyWaitReceivePortEx=0x2e,0x0128,5,
NtReplyWaitReplyPort=0x2e,0x0129,2,
NtRequestPort=0x2e,0x012a,2,
NtRequestWaitReplyPort=0x2e,0x012b,3,
NtResetEvent=0x2e,0x012c,2,
NtResetWriteWatch=0x2e,0x012d,3,
NtRestoreKey=0x2e,0x012e,3,
NtResumeProcess=0x2e,0x012f,1,
NtResumeThread=0x2e,0x0130,2,
NtRollbackComplete=0x2e,0x0131,2,
NtRollbackEnlistment=0x2e,0x0132,2,
NtRollbackTransaction=0x2e,0x0133,2,
NtRollforwardTransactionManager=0x2e,0x0134,2,
NtSaveKey=0x2e,0x0135,2,
NtSaveKeyEx=0x2e,0x0136,3,
NtSaveMergedKeys=0x2e,0x0137,3,
NtSecureConnectPort=0x2e,0x0138,9,
NtSerializeBoot=0x2e,0x0139,0,
NtSetBootEntryOrder=0x2e,0x013a,2,
NtSetBootOptions=0x2e,0x013b,2,
NtSetContextThread=0x2e,0x013c,2,
NtSetDebugFilterState=0x2e,0x013d,3,
NtSetDefaultHardErrorPort=0x2e,0x013e,1,
NtSetDefaultLocale=0x2e,0x013f,2,
NtSetDefaultUILanguage=0x2e,0x0140,1,
NtSetDriverEntryOrder=0x2e,0x0141,2,
NtSetEaFile=0x2e,0x0142,4,
NtSetEvent=0x2e,0x0143,2,
NtSetEventBoostPriority=0x2e,0x0144,1,
NtSetHighEventPair=0x2e,0x0145,1,
NtSetHighWaitLowEventPair=0x2e,0x0146,1,
NtSetInformationDebugObject=0x2e,0x0147,5,
NtSetInformationEnlistment=0x2e,0x0148,4,
NtSetInformationFile=0x2e,0x0149,5,
NtSetInformationJobObject=0x2e,0x014a,4,
NtSetInformationKey=0x2e,0x014b,4,
NtSetInformationObject=0x2e,0x014c,4,
NtSetInformationProcess=0x2e,0x014d,4,
NtSetInformationResourceManager=0x2e,0x014e,4,
NtSetInformationThread=0x2e,0x014f,4,
NtSetInformationToken=0x2e,0x0150,4,
NtSetInformationTransaction=0x2e,0x0151,4,
NtSetInformationTransactionManager=0x2e,0x0152,4,
NtSetInformationWorkerFactory=0x2e,0x0153,4,
NtSetIntervalProfile=0x2e,0x0154,2,
NtSetIoCompletion=0x2e,0x0155,5,
NtSetIoCompletionEx=0x2e,0x0156,6,
NtSetLdtEntries=0x2e,0x0157,6,
NtSetLowEventPair=0x2e,0x0158,1,
NtSetLowWaitHighEventPair=0x2e,0x0159,1,
NtSetQuotaInformationFile=0x2e,0x015a,4,
NtSetSecurityObject=0x2e,0x015b,3,
NtSetSystemEnvironmentValue=0x2e,0x015c,2,
NtSetSystemEnvironmentValueEx=0x2e,0x015d,5,
NtSetSystemInformation=0x2e,0x015e,3,
NtSetSystemPowerState=0x2e,0x015f,3,
NtSetSystemTime=0x2e,0x0160,2,
NtSetThreadExecutionState=0x2e,0x0161,2,
NtSetTimer=0x2e,0x0162,7,
NtSetTimerEx=0x2e,0x0163,4,
NtSetTimerResolution=0x2e,0x0164,3,
NtSetUuidSeed=0x2e,0x0165,1,
NtSetValueKey=0x2e,0x0166,6,
NtSetVolumeInformationFile=0x2e,0x0167,5,
NtShutdownSystem=0x2e,0x0168,1,
NtShutdownWorkerFactory=0x2e,0x0169,2,
NtSignalAndWaitForSingleObject=0x2e,0x016a,4,
NtSinglePhaseReject=0x2e,0x016b,2,
NtStartProfile=0x2e,0x016c,1,
NtStopProfile=0x2e,0x016d,1,
NtSuspendProcess=0x2e,0x016e,1,
NtSuspendThread=0x2e,0x016f,2,
NtSystemDebugControl=0x2e,0x0170,6,
NtTerminateJobObject=0x2e,0x0171,2,
NtTerminateProcess=0x2e,0x0172,2,
NtTerminateThread=0x2e,0x0173,2,
NtTestAlert=0x2e,0x0174,0,
NtThawRegistry=0x2e,0x0175,0,
NtThawTransactions=0x2e,0x0176,0,
NtTraceControl=0x2e,0x0177,6,
NtTraceEvent=0x2e,0x0178,4,
NtTranslateFilePath=0x2e,0x0179,4,
NtUmsThreadYield=0x2e,0x017a,1,
NtUnloadDriver=0x2e,0x017b,1,
NtUnloadKey=0x2e,0x017c,1,
NtUnloadKey2=0x2e,0x017d,2,
NtUnloadKeyEx=0x2e,0x017e,2,
NtUnlockFile=0x2e,0x017f,5,
NtUnlockVirtualMemory=0x2e,0x0180,4,
NtUnmapViewOfSection=0x2e,0x0181,2,
NtVdmControl=0x2e,0x0182,2,
NtWaitForDebugEvent=0x2e,0x0183,4,
NtWaitForKeyedEvent=0x2e,0x0184,4,
NtWaitForMultipleObjects=0x2e,0x0185,5,
NtWaitForMultipleObjects32=0x2e,0x0186,5,
NtWaitForSingleObject=0x2e,0x0187,3,
NtWaitForWorkViaWorkerFactory=0x2e,0x0188,2,
NtWaitHighEventPair=0x2e,0x0189,1,
NtWaitLowEventPair=0x2e,0x018a,1,
NtWorkerFactoryWorkerReady=0x2e,0x018b,1,
NtWriteFile=0x2e,0x018c,9,
NtWriteFileGather=0x2e,0x018d,9,
NtWriteRequestData=0x2e,0x018e,6,
NtWriteVirtualMemory=0x2e,0x018f,5,
NtYieldExecution=0x2e,0x0190,0,
NtGdiAbortDoc=0x2e,0x1000,1,
NtGdiAbortPath=0x2e,0x1001,1,
NtGdiAddFontResourceW=0x2e,0x1002,6,
NtGdiAddRemoteFontToDC=0x2e,0x1003,4,
NtGdiAddFontMemResourceEx=0x2e,0x1004,5,
NtGdiRemoveMergeFont=0x2e,0x1005,2,
NtGdiAddRemoteMMInstanceToDC=0x2e,0x1006,3,
NtGdiAlphaBlend=0x2e,0x1007,12,
NtGdiAngleArc=0x2e,0x1008,6,
NtGdiAnyLinkedFonts=0x2e,0x1009,0,
NtGdiFontIsLinked=0x2e,0x100a,1,
NtGdiArcInternal=0x2e,0x100b,10,
NtGdiBeginGdiRendering=0x2e,0x100c,2,
NtGdiBeginPath=0x2e,0x100d,1,
NtGdiBitBlt=0x2e,0x100e,11,
NtGdiCancelDC=0x2e,0x100f,1,
NtGdiCheckBitmapBits=0x2e,0x1010,8,
NtGdiCloseFigure=0x2e,0x1011,1,
NtGdiClearBitmapAttributes=0x2e,0x1012,2,
NtGdiClearBrushAttributes=0x2e,0x1013,2,
NtGdiColorCorrectPalette=0x2e,0x1014,6,
NtGdiCombineRgn=0x2e,0x1015,4,
NtGdiCombineTransform=0x2e,0x1016,3,
NtGdiComputeXformCoefficients=0x2e,0x1017,1,
NtGdiConfigureOPMProtectedOutput=0x2e,0x1018,4,
NtGdiConvertMetafileRect=0x2e,0x1019,2,
NtGdiCreateBitmap=0x2e,0x101a,5,
NtGdiCreateBitmapFromDxSurface=0x2e,0x101b,5,
NtGdiCreateClientObj=0x2e,0x101c,1,
NtGdiCreateColorSpace=0x2e,0x101d,1,
NtGdiCreateColorTransform=0x2e,0x101e,8,
NtGdiCreateCompatibleBitmap=0x2e,0x101f,3,
NtGdiCreateCompatibleDC=0x2e,0x1020,1,
NtGdiCreateDIBBrush=0x2e,0x1021,6,
NtGdiCreateDIBitmapInternal=0x2e,0x1022,11,
NtGdiCreateDIBSection=0x2e,0x1023,9,
NtGdiCreateEllipticRgn=0x2e,0x1024,4,
NtGdiCreateHalftonePalette=0x2e,0x1025,1,
NtGdiCreateHatchBrushInternal=0x2e,0x1026,3,
NtGdiCreateMetafileDC=0x2e,0x1027,1,
NtGdiCreateOPMProtectedOutputs=0x2e,0x1028,5,
NtGdiCreatePaletteInternal=0x2e,0x1029,2,
NtGdiCreatePatternBrushInternal=0x2e,0x102a,3,
NtGdiCreatePen=0x2e,0x102b,4,
NtGdiCreateRectRgn=0x2e,0x102c,4,
NtGdiCreateRoundRectRgn=0x2e,0x102d,6,
NtGdiCreateServerMetaFile=0x2e,0x102e,6,
NtGdiCreateSolidBrush=0x2e,0x102f,2,
NtGdiD3dContextCreate=0x2e,0x1030,4,
NtGdiD3dContextDestroy=0x2e,0x1031,1,
NtGdiD3dContextDestroyAll=0x2e,0x1032,1,
NtGdiD3dValidateTextureStageState=0x2e,0x1033,1,
NtGdiD3dDrawPrimitives2=0x2e,0x1034,7,
NtGdiDdGetDriverState=0x2e,0x1035,1,
NtGdiDdAddAttachedSurface=0x2e,0x1036,3,
NtGdiDdAlphaBlt=0x2e,0x1037,3,
NtGdiDdAttachSurface=0x2e,0x1038,2,
NtGdiDdBeginMoCompFrame=0x2e,0x1039,2,
NtGdiDdBlt=0x2e,0x103a,3,
NtGdiDdCanCreateSurface=0x2e,0x103b,2,
NtGdiDdCanCreateD3DBuffer=0x2e,0x103c,2,
NtGdiDdColorControl=0x2e,0x103d,2,
NtGdiDdCreateDirectDrawObject=0x2e,0x103e,1,
NtGdiDdCreateSurface=0x2e,0x103f,8,
NtGdiDdCreateD3DBuffer=0x2e,0x1040,8,
NtGdiDdCreateMoComp=0x2e,0x1041,2,
NtGdiDdCreateSurfaceObject=0x2e,0x1042,6,
NtGdiDdDeleteDirectDrawObject=0x2e,0x1043,1,
NtGdiDdDeleteSurfaceObject=0x2e,0x1044,1,
NtGdiDdDestroyMoComp=0x2e,0x1045,2,
NtGdiDdDestroySurface=0x2e,0x1046,2,
NtGdiDdDestroyD3DBuffer=0x2e,0x1047,1,
NtGdiDdEndMoCompFrame=0x2e,0x1048,2,
NtGdiDdFlip=0x2e,0x1049,5,
NtGdiDdFlipToGDISurface=0x2e,0x104a,2,
NtGdiDdGetAvailDriverMemory=0x2e,0x104b,2,
NtGdiDdGetBltStatus=0x2e,0x104c,2,
NtGdiDdGetDC=0x2e,0x104d,2,
NtGdiDdGetDriverInfo=0x2e,0x104e,2,
NtGdiDdGetDxPlugin=0x2e,0x104f,3,
NtGdiDdGetFlipStatus=0x2e,0x1050,2,
NtGdiDdGetInternalMoCompInfo=0x2e,0x1051,2,
NtGdiDdGetMoCompBuffInfo=0x2e,0x1052,2,
NtGdiDdGetMoCompGuids=0x2e,0x1053,2,
NtGdiDdGetMoCompFormats=0x2e,0x1054,2,
NtGdiDdGetScanLine=0x2e,0x1055,2,
NtGdiDdLock=0x2e,0x1056,3,
NtGdiDdLockD3D=0x2e,0x1057,2,
NtGdiDdQueryDirectDrawObject=0x2e,0x1058,11,
NtGdiDdQueryMoCompStatus=0x2e,0x1059,2,
NtGdiDdReenableDirectDrawObject=0x2e,0x105a,2,
NtGdiDdReleaseDC=0x2e,0x105b,1,
NtGdiDdRenderMoComp=0x2e,0x105c,2,
NtGdiDdResetVisrgn=0x2e,0x105d,2,
NtGdiDdSetColorKey=0x2e,0x105e,2,
NtGdiDdSetExclusiveMode=0x2e,0x105f,2,
NtGdiDdSetGammaRamp=0x2e,0x1060,3,
NtGdiDdCreateSurfaceEx=0x2e,0x1061,3,
NtGdiDdSetOverlayPosition=0x2e,0x1062,3,
NtGdiDdUnattachSurface=0x2e,0x1063,2,
NtGdiDdUnlock=0x2e,0x1064,2,
NtGdiDdUnlockD3D=0x2e,0x1065,2,
NtGdiDdUpdateOverlay=0x2e,0x1066,3,
NtGdiDdWaitForVerticalBlank=0x2e,0x1067,2,
NtGdiDvpCanCreateVideoPort=0x2e,0x1068,2,
NtGdiDvpColorControl=0x2e,0x1069,2,
NtGdiDvpCreateVideoPort=0x2e,0x106a,2,
NtGdiDvpDestroyVideoPort=0x2e,0x106b,2,
NtGdiDvpFlipVideoPort=0x2e,0x106c,4,
NtGdiDvpGetVideoPortBandwidth=0x2e,0x106d,2,
NtGdiDvpGetVideoPortField=0x2e,0x106e,2,
NtGdiDvpGetVideoPortFlipStatus=0x2e,0x106f,2,
NtGdiDvpGetVideoPortInputFormats=0x2e,0x1070,2,
NtGdiDvpGetVideoPortLine=0x2e,0x1071,2,
NtGdiDvpGetVideoPortOutputFormats=0x2e,0x1072,2,
NtGdiDvpGetVideoPortConnectInfo=0x2e,0x1073,2,
NtGdiDvpGetVideoSignalStatus=0x2e,0x1074,2,
NtGdiDvpUpdateVideoPort=0x2e,0x1075,4,
NtGdiDvpWaitForVideoPortSync=0x2e,0x1076,2,
NtGdiDvpAcquireNotification=0x2e,0x1077,3,
NtGdiDvpReleaseNotification=0x2e,0x1078,2,
NtGdiDxgGenericThunk=0x2e,0x1079,6,
NtGdiDeleteClientObj=0x2e,0x107a,1,
NtGdiDeleteColorSpace=0x2e,0x107b,1,
NtGdiDeleteColorTransform=0x2e,0x107c,2,
NtGdiDeleteObjectApp=0x2e,0x107d,1,
NtGdiDescribePixelFormat=0x2e,0x107e,4,
NtGdiDestroyOPMProtectedOutput=0x2e,0x107f,1,
NtGdiGetPerBandInfo=0x2e,0x1080,2,
NtGdiDoBanding=0x2e,0x1081,4,
NtGdiDoPalette=0x2e,0x1082,6,
NtGdiDrawEscape=0x2e,0x1083,4,
NtGdiEllipse=0x2e,0x1084,5,
NtGdiEnableEudc=0x2e,0x1085,1,
NtGdiEndDoc=0x2e,0x1086,1,
NtGdiEndGdiRendering=0x2e,0x1087,3,
NtGdiEndPage=0x2e,0x1088,1,
NtGdiEndPath=0x2e,0x1089,1,
NtGdiEnumFonts=0x2e,0x108a,8,
NtGdiEnumObjects=0x2e,0x108b,4,
NtGdiEqualRgn=0x2e,0x108c,2,
NtGdiEudcLoadUnloadLink=0x2e,0x108d,7,
NtGdiExcludeClipRect=0x2e,0x108e,5,
NtGdiExtCreatePen=0x2e,0x108f,11,
NtGdiExtCreateRegion=0x2e,0x1090,3,
NtGdiExtEscape=0x2e,0x1091,8,
NtGdiExtFloodFill=0x2e,0x1092,5,
NtGdiExtGetObjectW=0x2e,0x1093,3,
NtGdiExtSelectClipRgn=0x2e,0x1094,3,
NtGdiExtTextOutW=0x2e,0x1095,9,
NtGdiFillPath=0x2e,0x1096,1,
NtGdiFillRgn=0x2e,0x1097,3,
NtGdiFlattenPath=0x2e,0x1098,1,
NtGdiFlush=0x2e,0x1099,0,
NtGdiForceUFIMapping=0x2e,0x109a,2,
NtGdiFrameRgn=0x2e,0x109b,5,
NtGdiFullscreenControl=0x2e,0x109c,5,
NtGdiGetAndSetDCDword=0x2e,0x109d,4,
NtGdiGetAppClipBox=0x2e,0x109e,2,
NtGdiGetBitmapBits=0x2e,0x109f,3,
NtGdiGetBitmapDimension=0x2e,0x10a0,2,
NtGdiGetBoundsRect=0x2e,0x10a1,3,
NtGdiGetCertificate=0x2e,0x10a2,4,
NtGdiGetCertificateSize=0x2e,0x10a3,3,
NtGdiGetCharABCWidthsW=0x2e,0x10a4,6,
NtGdiGetCharacterPlacementW=0x2e,0x10a5,6,
NtGdiGetCharSet=0x2e,0x10a6,1,
NtGdiGetCharWidthW=0x2e,0x10a7,6,
NtGdiGetCharWidthInfo=0x2e,0x10a8,2,
NtGdiGetColorAdjustment=0x2e,0x10a9,2,
NtGdiGetColorSpaceforBitmap=0x2e,0x10aa,1,
NtGdiGetCOPPCompatibleOPMInformation=0x2e,0x10ab,3,
NtGdiGetDCDword=0x2e,0x10ac,3,
NtGdiGetDCforBitmap=0x2e,0x10ad,1,
NtGdiGetDCObject=0x2e,0x10ae,2,
NtGdiGetDCPoint=0x2e,0x10af,3,
NtGdiGetDeviceCaps=0x2e,0x10b0,2,
NtGdiGetDeviceGammaRamp=0x2e,0x10b1,2,
NtGdiGetDeviceCapsAll=0x2e,0x10b2,2,
NtGdiGetDIBitsInternal=0x2e,0x10b3,9,
NtGdiGetETM=0x2e,0x10b4,2,
NtGdiGetEudcTimeStampEx=0x2e,0x10b5,3,
NtGdiGetFontData=0x2e,0x10b6,5,
NtGdiGetFontFileData=0x2e,0x10b7,5,
NtGdiGetFontFileInfo=0x2e,0x10b8,5,
NtGdiGetFontResourceInfoInternalW=0x2e,0x10b9,7,
NtGdiGetGlyphIndicesW=0x2e,0x10ba,5,
NtGdiGetGlyphIndicesWInternal=0x2e,0x10bb,6,
NtGdiGetGlyphOutline=0x2e,0x10bc,8,
NtGdiGetOPMInformation=0x2e,0x10bd,3,
NtGdiGetKerningPairs=0x2e,0x10be,3,
NtGdiGetLinkedUFIs=0x2e,0x10bf,3,
NtGdiGetMiterLimit=0x2e,0x10c0,2,
NtGdiGetMonitorID=0x2e,0x10c1,3,
NtGdiGetNearestColor=0x2e,0x10c2,2,
NtGdiGetNearestPaletteIndex=0x2e,0x10c3,2,
NtGdiGetObjectBitmapPlugin=0x2e,0x10c4,2,
NtGdiGetOPMRandomNumber=0x2e,0x10c5,2,
NtGdiGetOutlineTextMetricsInternalW=0x2e,0x10c6,4,
NtGdiGetPath=0x2e,0x10c7,4,
NtGdiGetPixel=0x2e,0x10c8,3,
NtGdiGetRandomRgn=0x2e,0x10c9,3,
NtGdiGetRasterizerCaps=0x2e,0x10ca,2,
NtGdiGetRealizationInfo=0x2e,0x10cb,2,
NtGdiGetRegionData=0x2e,0x10cc,3,
NtGdiGetRgnBox=0x2e,0x10cd,2,
NtGdiGetServerMetaFileBits=0x2e,0x10ce,7,
DxgStubDvpUpdateVideoPort=0x2e,0x10cf,4,
NtGdiGetStats=0x2e,0x10d0,5,
NtGdiGetStockObject=0x2e,0x10d1,1,
NtGdiGetStringBitmapW=0x2e,0x10d2,5,
NtGdiGetSuggestedOPMProtectedOutputArraySize=0x2e,0x10d3,2,
NtGdiGetSystemPaletteUse=0x2e,0x10d4,1,
NtGdiGetTextCharsetInfo=0x2e,0x10d5,3,
NtGdiGetTextExtent=0x2e,0x10d6,5,
NtGdiGetTextExtentExW=0x2e,0x10d7,8,
NtGdiGetTextFaceW=0x2e,0x10d8,4,
NtGdiGetTextMetricsW=0x2e,0x10d9,3,
NtGdiGetTransform=0x2e,0x10da,3,
NtGdiGetUFI=0x2e,0x10db,6,
NtGdiGetEmbUFI=0x2e,0x10dc,7,
NtGdiGetUFIPathname=0x2e,0x10dd,10,
NtGdiGetEmbedFonts=0x2e,0x10de,0,
NtGdiChangeGhostFont=0x2e,0x10df,2,
NtGdiAddEmbFontToDC=0x2e,0x10e0,2,
NtGdiGetFontUnicodeRanges=0x2e,0x10e1,2,
NtGdiGetWidthTable=0x2e,0x10e2,7,
NtGdiGradientFill=0x2e,0x10e3,6,
NtGdiHfontCreate=0x2e,0x10e4,5,
NtGdiIcmBrushInfo=0x2e,0x10e5,8,
bInitRedirDev=0x2e,0x10e6,0,
NtGdiInitSpool=0x2e,0x10e7,0,
NtGdiIntersectClipRect=0x2e,0x10e8,5,
NtGdiInvertRgn=0x2e,0x10e9,2,
NtGdiLineTo=0x2e,0x10ea,3,
NtGdiMakeFontDir=0x2e,0x10eb,5,
NtGdiMakeInfoDC=0x2e,0x10ec,2,
NtGdiMaskBlt=0x2e,0x10ed,13,
NtGdiModifyWorldTransform=0x2e,0x10ee,3,
NtGdiMonoBitmap=0x2e,0x10ef,1,
NtGdiMoveTo=0x2e,0x10f0,4,
NtGdiOffsetClipRgn=0x2e,0x10f1,3,
NtGdiOffsetRgn=0x2e,0x10f2,3,
NtGdiOpenDCW=0x2e,0x10f3,8,
NtGdiPatBlt=0x2e,0x10f4,6,
NtGdiPolyPatBlt=0x2e,0x10f5,5,
NtGdiPathToRegion=0x2e,0x10f6,1,
NtGdiPlgBlt=0x2e,0x10f7,11,
NtGdiPolyDraw=0x2e,0x10f8,4,
NtGdiPolyPolyDraw=0x2e,0x10f9,5,
NtGdiPolyTextOutW=0x2e,0x10fa,4,
NtGdiPtInRegion=0x2e,0x10fb,3,
NtGdiPtVisible=0x2e,0x10fc,3,
NtGdiQueryFonts=0x2e,0x10fd,3,
NtGdiQueryFontAssocInfo=0x2e,0x10fe,1,
NtGdiRectangle=0x2e,0x10ff,5,
NtGdiRectInRegion=0x2e,0x1100,2,
NtGdiRectVisible=0x2e,0x1101,2,
NtGdiRemoveFontResourceW=0x2e,0x1102,6,
NtGdiRemoveFontMemResourceEx=0x2e,0x1103,1,
NtGdiResetDC=0x2e,0x1104,5,
NtGdiResizePalette=0x2e,0x1105,2,
NtGdiRestoreDC=0x2e,0x1106,2,
NtGdiRoundRect=0x2e,0x1107,7,
NtGdiSaveDC=0x2e,0x1108,1,
NtGdiScaleViewportExtEx=0x2e,0x1109,6,
NtGdiScaleWindowExtEx=0x2e,0x110a,6,
NtGdiSelectBitmap=0x2e,0x110b,2,
NtGdiSelectBrush=0x2e,0x110c,2,
NtGdiSelectClipPath=0x2e,0x110d,2,
NtGdiSelectFont=0x2e,0x110e,2,
NtGdiSelectPen=0x2e,0x110f,2,
NtGdiSetBitmapAttributes=0x2e,0x1110,2,
NtGdiSetBitmapBits=0x2e,0x1111,3,
NtGdiSetBitmapDimension=0x2e,0x1112,4,
NtGdiSetBoundsRect=0x2e,0x1113,3,
NtGdiSetBrushAttributes=0x2e,0x1114,2,
NtGdiSetBrushOrg=0x2e,0x1115,4,
NtGdiSetColorAdjustment=0x2e,0x1116,2,
NtGdiSetColorSpace=0x2e,0x1117,2,
NtGdiSetDeviceGammaRamp=0x2e,0x1118,2,
NtGdiSetDIBitsToDeviceInternal=0x2e,0x1119,16,
NtGdiSetFontEnumeration=0x2e,0x111a,1,
NtGdiSetFontXform=0x2e,0x111b,3,
NtGdiSetIcmMode=0x2e,0x111c,3,
NtGdiSetLinkedUFIs=0x2e,0x111d,3,
NtGdiSetMagicColors=0x2e,0x111e,3,
NtGdiSetMetaRgn=0x2e,0x111f,1,
NtGdiSetMiterLimit=0x2e,0x1120,3,
NtGdiGetDeviceWidth=0x2e,0x1121,1,
NtGdiMirrorWindowOrg=0x2e,0x1122,1,
NtGdiSetLayout=0x2e,0x1123,3,
NtGdiSetOPMSigningKeyAndSequenceNumbers=0x2e,0x1124,2,
NtGdiSetPixel=0x2e,0x1125,4,
NtGdiSetPixelFormat=0x2e,0x1126,2,
NtGdiSetRectRgn=0x2e,0x1127,5,
NtGdiSetSystemPaletteUse=0x2e,0x1128,2,
NtGdiSetTextJustification=0x2e,0x1129,3,
NtGdiSetVirtualResolution=0x2e,0x112a,5,
NtGdiSetSizeDevice=0x2e,0x112b,3,
NtGdiStartDoc=0x2e,0x112c,4,
NtGdiStartPage=0x2e,0x112d,1,
NtGdiStretchBlt=0x2e,0x112e,12,
NtGdiStretchDIBitsInternal=0x2e,0x112f,16,
NtGdiStrokeAndFillPath=0x2e,0x1130,1,
NtGdiStrokePath=0x2e,0x1131,1,
NtGdiSwapBuffers=0x2e,0x1132,1,
NtGdiTransformPoints=0x2e,0x1133,5,
NtGdiTransparentBlt=0x2e,0x1134,11,
DxgStubEndMoCompFrame=0x2e,0x1135,2,
NtGdiUMPDEngFreeUserMem=0x2e,0x1136,1,
NtGdiUnrealizeObject=0x2e,0x1137,1,
NtGdiUpdateColors=0x2e,0x1138,1,
NtGdiWidenPath=0x2e,0x1139,1,
NtUserActivateKeyboardLayout=0x2e,0x113a,2,
NtUserAddClipboardFormatListener=0x2e,0x113b,1,
NtUserAlterWindowStyle=0x2e,0x113c,3,
NtUserAssociateInputContext=0x2e,0x113d,3,
NtUserAttachThreadInput=0x2e,0x113e,3,
NtUserBeginPaint=0x2e,0x113f,2,
NtUserBitBltSysBmp=0x2e,0x1140,8,
NtUserBlockInput=0x2e,0x1141,1,
NtUserBuildHimcList=0x2e,0x1142,4,
NtUserBuildHwndList=0x2e,0x1143,7,
NtUserBuildNameList=0x2e,0x1144,4,
NtUserBuildPropList=0x2e,0x1145,4,
NtUserCallHwnd=0x2e,0x1146,2,
NtUserCallHwndLock=0x2e,0x1147,2,
NtUserCallHwndOpt=0x2e,0x1148,2,
NtUserCallHwndParam=0x2e,0x1149,3,
NtUserCallHwndParamLock=0x2e,0x114a,3,
NtUserCallMsgFilter=0x2e,0x114b,2,
NtUserCallNextHookEx=0x2e,0x114c,4,
NtUserCallNoParam=0x2e,0x114d,1,
NtUserCallOneParam=0x2e,0x114e,2,
NtUserCallTwoParam=0x2e,0x114f,3,
NtUserChangeClipboardChain=0x2e,0x1150,2,
NtUserChangeDisplaySettings=0x2e,0x1151,4,
NtUserGetDisplayConfigBufferSizes=0x2e,0x1152,3,
NtUserSetDisplayConfig=0x2e,0x1153,5,
NtUserQueryDisplayConfig=0x2e,0x1154,6,
NtUserDisplayConfigGetDeviceInfo=0x2e,0x1155,1,
NtUserDisplayConfigSetDeviceInfo=0x2e,0x1156,1,
NtUserCheckAccessForIntegrityLevel=0x2e,0x1157,3,
NtUserCheckDesktopByThreadId=0x2e,0x1158,1,
NtUserCheckWindowThreadDesktop=0x2e,0x1159,2,
NtUserCheckMenuItem=0x2e,0x115a,3,
NtUserChildWindowFromPointEx=0x2e,0x115b,4,
NtUserClipCursor=0x2e,0x115c,1,
NtUserCloseClipboard=0x2e,0x115d,0,
NtUserCloseDesktop=0x2e,0x115e,1,
NtUserCloseWindowStation=0x2e,0x115f,1,
NtUserConsoleControl=0x2e,0x1160,3,
NtUserConvertMemPlugin=0x2e,0x1161,2,
NtUserCopyAcceleratorTable=0x2e,0x1162,3,
NtUserCountClipboardFormats=0x2e,0x1163,0,
NtUserCreateAcceleratorTable=0x2e,0x1164,2,
NtUserCreateCaret=0x2e,0x1165,4,
NtUserCreateDesktopEx=0x2e,0x1166,6,
NtUserCreateInputContext=0x2e,0x1167,1,
NtUserCreateLocalMemPlugin=0x2e,0x1168,4,
NtUserCreateWindowEx=0x2e,0x1169,15,
NtUserCreateWindowStation=0x2e,0x116a,8,
NtUserDdeInitialize=0x2e,0x116b,5,
NtUserDeferWindowPos=0x2e,0x116c,8,
NtUserDefSetText=0x2e,0x116d,2,
NtUserDeleteMenu=0x2e,0x116e,3,
NtUserDestroyAcceleratorTable=0x2e,0x116f,1,
NtUserDestroyCursor=0x2e,0x1170,2,
NtUserDestroyInputContext=0x2e,0x1171,1,
NtUserDestroyMenu=0x2e,0x1172,1,
NtUserDestroyWindow=0x2e,0x1173,1,
NtUserDisableThreadIme=0x2e,0x1174,1,
NtUserDispatchMessage=0x2e,0x1175,1,
NtUserDoSoundConnect=0x2e,0x1176,0,
NtUserDoSoundDisconnect=0x2e,0x1177,0,
NtUserDragDetect=0x2e,0x1178,3,
NtUserDragObject=0x2e,0x1179,5,
NtUserDrawAnimatedRects=0x2e,0x117a,4,
NtUserDrawCaption=0x2e,0x117b,4,
NtUserDrawCaptionTemp=0x2e,0x117c,7,
NtUserDrawIconEx=0x2e,0x117d,11,
NtUserDrawMenuBarTemp=0x2e,0x117e,5,
NtUserEmptyClipboard=0x2e,0x117f,0,
NtUserEnableMenuItem=0x2e,0x1180,3,
NtUserEnableScrollBar=0x2e,0x1181,3,
NtUserEndDeferWindowPosEx=0x2e,0x1182,2,
NtUserEndMenu=0x2e,0x1183,0,
NtUserEndPaint=0x2e,0x1184,2,
NtUserEnumDisplayDevices=0x2e,0x1185,4,
NtUserEnumDisplayMonitors=0x2e,0x1186,4,
NtUserEnumDisplaySettings=0x2e,0x1187,4,
NtUserEvent=0x2e,0x1188,1,
NtUserExcludeUpdateRgn=0x2e,0x1189,2,
NtUserFillWindow=0x2e,0x118a,4,
NtUserFindExistingCursorIcon=0x2e,0x118b,3,
NtUserFindWindowEx=0x2e,0x118c,5,
NtUserFlashWindowEx=0x2e,0x118d,1,
NtUserFrostCrashedWindow=0x2e,0x118e,2,
NtUserGetAltTabInfo=0x2e,0x118f,6,
NtUserGetAncestor=0x2e,0x1190,2,
NtUserGetAppImeLevel=0x2e,0x1191,1,
NtUserGetAsyncKeyState=0x2e,0x1192,1,
NtUserGetAtomName=0x2e,0x1193,2,
NtUserGetCaretBlinkTime=0x2e,0x1194,0,
NtUserGetCaretPos=0x2e,0x1195,1,
NtUserGetClassInfoEx=0x2e,0x1196,5,
NtUserGetClassName=0x2e,0x1197,3,
NtUserGetClipboardData=0x2e,0x1198,2,
NtUserGetClipboardFormatName=0x2e,0x1199,3,
NtUserGetClipboardOwner=0x2e,0x119a,0,
NtUserGetClipboardSequenceNumber=0x2e,0x119b,0,
NtUserGetClipboardViewer=0x2e,0x119c,0,
NtUserGetClipCursor=0x2e,0x119d,1,
NtUserGetComboBoxInfo=0x2e,0x119e,2,
NtUserGetControlBrush=0x2e,0x119f,3,
NtUserGetControlColor=0x2e,0x11a0,4,
NtUserGetCPD=0x2e,0x11a1,3,
NtUserGetCursorFrameInfo=0x2e,0x11a2,4,
NtUserGetCursorInfo=0x2e,0x11a3,1,
NtUserGetDC=0x2e,0x11a4,1,
NtUserGetDCEx=0x2e,0x11a5,3,
NtUserGetDoubleClickTime=0x2e,0x11a6,0,
NtUserGetForegroundWindow=0x2e,0x11a7,0,
NtUserGetGuiResources=0x2e,0x11a8,2,
NtUserGetGUIThreadInfo=0x2e,0x11a9,2,
NtUserGetIconInfo=0x2e,0x11aa,6,
NtUserGetIconSize=0x2e,0x11ab,4,
NtUserGetImeHotKey=0x2e,0x11ac,4,
NtUserGetImeInfoEx=0x2e,0x11ad,2,
NtUserGetInputLocaleInfo=0x2e,0x11ae,2,
NtUserGetInternalWindowPos=0x2e,0x11af,3,
NtUserGetKeyboardLayoutList=0x2e,0x11b0,2,
NtUserGetKeyboardLayoutName=0x2e,0x11b1,1,
NtUserGetKeyboardState=0x2e,0x11b2,1,
NtUserGetKeyNameText=0x2e,0x11b3,3,
NtUserGetKeyState=0x2e,0x11b4,1,
NtUserGetListBoxInfo=0x2e,0x11b5,1,
NtUserGetMenuBarInfo=0x2e,0x11b6,4,
NtUserGetMenuIndex=0x2e,0x11b7,2,
NtUserGetMenuItemRect=0x2e,0x11b8,4,
NtUserGetMessage=0x2e,0x11b9,4,
NtUserGetMouseMovePointsEx=0x2e,0x11ba,5,
NtUserGetObjectInformation=0x2e,0x11bb,5,
NtUserGetOpenClipboardWindow=0x2e,0x11bc,0,
NtUserGetPriorityClipboardFormat=0x2e,0x11bd,2,
NtUserGetProcessWindowStation=0x2e,0x11be,0,
NtUserGetRawInputBuffer=0x2e,0x11bf,3,
NtUserGetRawInputData=0x2e,0x11c0,5,
NtUserGetRawInputDeviceInfo=0x2e,0x11c1,4,
NtUserGetRawInputDeviceList=0x2e,0x11c2,3,
NtUserGetRegisteredRawInputDevices=0x2e,0x11c3,3,
NtUserGetScrollBarInfo=0x2e,0x11c4,3,
NtUserGetSystemMenu=0x2e,0x11c5,2,
NtUserGetThreadDesktop=0x2e,0x11c6,1,
NtUserGetThreadState=0x2e,0x11c7,1,
NtUserGetTitleBarInfo=0x2e,0x11c8,2,
NtUserGetTopLevelWindow=0x2e,0x11c9,1,
NtUserGetUpdatedClipboardFormats=0x2e,0x11ca,3,
NtUserGetUpdateRect=0x2e,0x11cb,3,
NtUserGetUpdateRgn=0x2e,0x11cc,3,
NtUserGetWindowCompositionInfo=0x2e,0x11cd,2,
NtUserGetWindowCompositionAttribute=0x2e,0x11ce,2,
NtUserGetWindowDC=0x2e,0x11cf,1,
NtUserGetWindowDisplayAffinity=0x2e,0x11d0,2,
NtUserGetWindowPlacement=0x2e,0x11d1,2,
NtUserGetWOWClass=0x2e,0x11d2,2,
NtUserGhostWindowFromHungWindow=0x2e,0x11d3,1,
NtUserHardErrorControl=0x2e,0x11d4,3,
NtUserHideCaret=0x2e,0x11d5,1,
NtUserHiliteMenuItem=0x2e,0x11d6,4,
NtUserHungWindowFromGhostWindow=0x2e,0x11d7,1,
NtUserImpersonateDdeClientWindow=0x2e,0x11d8,2,
NtUserInitialize=0x2e,0x11d9,2,
NtUserInitializeClientPfnArrays=0x2e,0x11da,4,
NtUserInitTask=0x2e,0x11db,12,
NtUserInternalGetWindowText=0x2e,0x11dc,3,
NtUserInternalGetWindowIcon=0x2e,0x11dd,2,
NtUserInvalidateRect=0x2e,0x11de,3,
NtUserInvalidateRgn=0x2e,0x11df,3,
NtUserIsClipboardFormatAvailable=0x2e,0x11e0,1,
NtUserIsTopLevelWindow=0x2e,0x11e1,1,
NtUserKillTimer=0x2e,0x11e2,2,
NtUserLoadKeyboardLayoutEx=0x2e,0x11e3,8,
NtUserLockWindowStation=0x2e,0x11e4,1,
NtUserLockWindowUpdate=0x2e,0x11e5,1,
NtUserLockWorkStation=0x2e,0x11e6,0,
NtUserLogicalToPhysicalPoint=0x2e,0x11e7,2,
NtUserMapVirtualKeyEx=0x2e,0x11e8,4,
NtUserMenuItemFromPoint=0x2e,0x11e9,4,
NtUserMessageCall=0x2e,0x11ea,7,
NtUserMinMaximize=0x2e,0x11eb,3,
NtUserMNDragLeave=0x2e,0x11ec,0,
NtUserMNDragOver=0x2e,0x11ed,2,
NtUserModifyUserStartupInfoFlags=0x2e,0x11ee,2,
NtUserMoveWindow=0x2e,0x11ef,6,
NtUserNotifyIMEStatus=0x2e,0x11f0,3,
NtUserNotifyProcessCreate=0x2e,0x11f1,4,
NtUserNotifyWinEvent=0x2e,0x11f2,4,
NtUserOpenClipboard=0x2e,0x11f3,2,
NtUserOpenDesktop=0x2e,0x11f4,3,
NtUserOpenInputDesktop=0x2e,0x11f5,3,
NtUserOpenThreadDesktop=0x2e,0x11f6,4,
NtUserOpenWindowStation=0x2e,0x11f7,2,
NtUserPaintDesktop=0x2e,0x11f8,1,
NtUserPaintMonitor=0x2e,0x11f9,3,
NtUserPeekMessage=0x2e,0x11fa,5,
NtUserPhysicalToLogicalPoint=0x2e,0x11fb,2,
NtUserPostMessage=0x2e,0x11fc,4,
NtUserPostThreadMessage=0x2e,0x11fd,4,
NtUserPrintWindow=0x2e,0x11fe,3,
NtUserProcessConnect=0x2e,0x11ff,2,
NtUserQueryInformationThread=0x2e,0x1200,4,
NtUserQueryInputContext=0x2e,0x1201,2,
NtUserQuerySendMessage=0x2e,0x1202,1,
NtUserQueryWindow=0x2e,0x1203,2,
NtUserRealChildWindowFromPoint=0x2e,0x1204,3,
NtUserRealInternalGetMessage=0x2e,0x1205,6,
NtUserRealWaitMessageEx=0x2e,0x1206,2,
NtUserRedrawWindow=0x2e,0x1207,4,
NtUserRegisterClassExWOW=0x2e,0x1208,7,
NtUserRegisterErrorReportingDialog=0x2e,0x1209,2,
NtUserRegisterUserApiHook=0x2e,0x120a,4,
NtUserRegisterHotKey=0x2e,0x120b,4,
NtUserRegisterRawInputDevices=0x2e,0x120c,3,
NtUserRegisterServicesProcess=0x2e,0x120d,1,
NtUserRegisterTasklist=0x2e,0x120e,1,
NtUserRegisterWindowMessage=0x2e,0x120f,1,
NtUserRemoveClipboardFormatListener=0x2e,0x1210,1,
NtUserRemoveMenu=0x2e,0x1211,3,
NtUserRemoveProp=0x2e,0x1212,2,
NtUserResolveDesktopForWOW=0x2e,0x1213,1,
NtUserSBGetParms=0x2e,0x1214,4,
NtUserScrollDC=0x2e,0x1215,7,
NtUserScrollWindowEx=0x2e,0x1216,8,
NtUserSelectPalette=0x2e,0x1217,3,
NtUserSendInput=0x2e,0x1218,3,
NtUserSetActiveWindow=0x2e,0x1219,1,
NtUserSetAppImeLevel=0x2e,0x121a,2,
NtUserSetCapture=0x2e,0x121b,1,
NtUserSetChildWindowNoActivate=0x2e,0x121c,1,
NtUserSetClassLong=0x2e,0x121d,4,
NtUserSetClassWord=0x2e,0x121e,3,
NtUserSetClipboardData=0x2e,0x121f,3,
NtUserSetClipboardViewer=0x2e,0x1220,1,
NtUserSetCursor=0x2e,0x1221,1,
NtUserSetCursorContents=0x2e,0x1222,2,
NtUserSetCursorIconData=0x2e,0x1223,4,
NtUserSetFocus=0x2e,0x1224,1,
NtUserSetImeHotKey=0x2e,0x1225,5,
NtUserSetImeInfoEx=0x2e,0x1226,1,
NtUserSetImeOwnerWindow=0x2e,0x1227,2,
NtUserSetInformationThread=0x2e,0x1228,4,
NtUserSetInternalWindowPos=0x2e,0x1229,4,
NtUserSetKeyboardState=0x2e,0x122a,1,
NtUserSetMenu=0x2e,0x122b,3,
NtUserSetMenuContextHelpId=0x2e,0x122c,2,
NtUserSetMenuDefaultItem=0x2e,0x122d,3,
NtUserSetMenuFlagRtoL=0x2e,0x122e,1,
NtUserSetObjectInformation=0x2e,0x122f,4,
NtUserSetParent=0x2e,0x1230,2,
NtUserSetProcessWindowStation=0x2e,0x1231,1,
NtUserGetProp=0x2e,0x1232,2,
NtUserSetProp=0x2e,0x1233,3,
NtUserSetScrollInfo=0x2e,0x1234,4,
NtUserSetShellWindowEx=0x2e,0x1235,2,
NtUserSetSysColors=0x2e,0x1236,4,
NtUserSetSystemCursor=0x2e,0x1237,2,
NtUserSetSystemMenu=0x2e,0x1238,2,
NtUserSetSystemTimer=0x2e,0x1239,3,
NtUserSetThreadDesktop=0x2e,0x123a,1,
NtUserSetThreadLayoutPlugins=0x2e,0x123b,2,
NtUserSetThreadState=0x2e,0x123c,2,
NtUserSetTimer=0x2e,0x123d,4,
NtUserSetProcessDPIAware=0x2e,0x123e,0,
NtUserSetWindowCompositionAttribute=0x2e,0x123f,2,
NtUserSetWindowDisplayAffinity=0x2e,0x1240,2,
NtUserSetWindowFNID=0x2e,0x1241,2,
NtUserSetWindowLong=0x2e,0x1242,4,
NtUserSetWindowPlacement=0x2e,0x1243,2,
NtUserSetWindowPos=0x2e,0x1244,7,
NtUserSetWindowRgn=0x2e,0x1245,3,
NtUserGetWindowRgnEx=0x2e,0x1246,3,
NtUserSetWindowRgnEx=0x2e,0x1247,3,
NtUserSetWindowsHookAW=0x2e,0x1248,3,
NtUserSetWindowsHookEx=0x2e,0x1249,6,
NtUserSetWindowStationUser=0x2e,0x124a,4,
NtUserSetWindowWord=0x2e,0x124b,3,
NtUserSetWinEventHook=0x2e,0x124c,8,
NtUserShowCaret=0x2e,0x124d,1,
NtUserShowScrollBar=0x2e,0x124e,3,
NtUserShowWindow=0x2e,0x124f,2,
NtUserShowWindowAsync=0x2e,0x1250,2,
NtUserSoundSentry=0x2e,0x1251,0,
NtUserSwitchDesktop=0x2e,0x1252,2,
NtUserSystemParametersInfo=0x2e,0x1253,4,
NtUserTestForInteractiveUser=0x2e,0x1254,1,
NtUserThunkedMenuInfo=0x2e,0x1255,2,
NtUserThunkedMenuItemInfo=0x2e,0x1256,6,
NtUserToUnicodeEx=0x2e,0x1257,7,
NtUserTrackMouseEvent=0x2e,0x1258,1,
NtUserTrackPopupMenuEx=0x2e,0x1259,6,
NtUserCalculatePopupWindowPosition=0x2e,0x125a,5,
NtUserCalcMenuBar=0x2e,0x125b,5,
NtUserPaintMenuBar=0x2e,0x125c,6,
NtUserTranslateAccelerator=0x2e,0x125d,3,
NtUserTranslateMessage=0x2e,0x125e,2,
NtUserUnhookWindowsHookEx=0x2e,0x125f,1,
NtUserUnhookWinEvent=0x2e,0x1260,1,
NtUserUnloadKeyboardLayout=0x2e,0x1261,1,
NtUserUnlockWindowStation=0x2e,0x1262,1,
NtUserUnregisterClass=0x2e,0x1263,3,
NtUserUnregisterUserApiHook=0x2e,0x1264,0,
NtUserUnregisterHotKey=0x2e,0x1265,2,
NtUserUpdateInputContext=0x2e,0x1266,3,
NtUserUpdateInstance=0x2e,0x1267,3,
NtUserUpdateLayeredWindow=0x2e,0x1268,10,
NtUserGetLayeredWindowAttributes=0x2e,0x1269,4,
NtUserSetLayeredWindowAttributes=0x2e,0x126a,4,
NtUserUpdatePerUserSystemParameters=0x2e,0x126b,1,
NtUserUserPluginGrantAccess=0x2e,0x126c,3,
NtUserValidatePluginSecure=0x2e,0x126d,1,
NtUserValidateRect=0x2e,0x126e,2,
NtUserValidateTimerCallback=0x2e,0x126f,1,
NtUserVkKeyScanEx=0x2e,0x1270,3,
NtUserWaitForInputIdle=0x2e,0x1271,3,
NtUserWaitForMsgAndEvent=0x2e,0x1272,1,
NtUserWaitMessage=0x2e,0x1273,0,
NtUserWindowFromPhysicalPoint=0x2e,0x1274,2,
NtUserWindowFromPoint=0x2e,0x1275,2,
NtUserYieldTask=0x2e,0x1276,0,
NtUserRemoteConnect=0x2e,0x1277,3,
NtUserRemoteRedrawRectangle=0x2e,0x1278,4,
NtUserRemoteRedrawScreen=0x2e,0x1279,0,
NtUserRemoteStopScreenUpdates=0x2e,0x127a,0,
NtUserCtxDisplayIOCtl=0x2e,0x127b,3,
NtUserRegisterSessionPort=0x2e,0x127c,2,
NtUserUnregisterSessionPort=0x2e,0x127d,0,
NtUserUpdateWindowTransform=0x2e,0x127e,3,
NtUserDwmStartRedirection=0x2e,0x127f,1,
NtUserDwmStopRedirection=0x2e,0x1280,0,
NtUserGetWindowMinimizeRect=0x2e,0x1281,2,
NtUserSfmDxBindSwapChain=0x2e,0x1282,3,
NtUserSfmDxOpenSwapChain=0x2e,0x1283,4,
NtUserSfmDxReleaseSwapChain=0x2e,0x1284,2,
NtUserSfmDxSetSwapChainBindingStatus=0x2e,0x1285,2,
NtUserSfmDxQuerySwapChainBindingStatus=0x2e,0x1286,3,
NtUserSfmDxReportPendingBindingsToDwm=0x2e,0x1287,0,
NtUserSfmDxGetSwapChainStats=0x2e,0x1288,2,
NtUserSfmDxSetSwapChainStats=0x2e,0x1289,2,
NtUserSfmGetLogicalSurfaceBinding=0x2e,0x128a,4,
NtUserSfmDestroyLogicalSurfaceBinding=0x2e,0x128b,1,
NtUserModifyWindowTouchCapability=0x2e,0x128c,3,
NtUserIsTouchWindow=0x2e,0x128d,2,
NtUserSendTouchInput=0x2e,0x128e,4,
NtUserEndTouchOperation=0x2e,0x128f,1,
NtUserGetTouchInputInfo=0x2e,0x1290,4,
NtUserChangeWindowMessageFilterEx=0x2e,0x1291,4,
NtUserInjectGesture=0x2e,0x1292,5,
NtUserGetGestureInfo=0x2e,0x1293,2,
NtUserGetGestureExtArgs=0x2e,0x1294,3,
NtUserManageGesturePluginWindow=0x2e,0x1295,2,
NtUserSetGestureConfig=0x2e,0x1296,5,
NtUserGetGestureConfig=0x2e,0x1297,6,
NtGdiEngAssociateSurface=0x2e,0x1298,3,
NtGdiEngCreateBitmap=0x2e,0x1299,6,
NtGdiEngCreateDeviceSurface=0x2e,0x129a,4,
NtGdiEngCreateDeviceBitmap=0x2e,0x129b,4,
NtGdiEngCreatePalette=0x2e,0x129c,6,
NtGdiEngComputeGlyphSet=0x2e,0x129d,3,
NtGdiEngCopyBits=0x2e,0x129e,6,
NtGdiEngDeletePalette=0x2e,0x129f,1,
NtGdiEngDeleteSurface=0x2e,0x12a0,1,
NtGdiEngEraseSurface=0x2e,0x12a1,3,
NtGdiEngUnlockSurface=0x2e,0x12a2,1,
NtGdiEngLockSurface=0x2e,0x12a3,1,
NtGdiEngBitBlt=0x2e,0x12a4,11,
NtGdiEngStretchBlt=0x2e,0x12a5,11,
NtGdiEngPlgBlt=0x2e,0x12a6,11,
NtGdiEngMarkBandingSurface=0x2e,0x12a7,1,
NtGdiEngStrokePath=0x2e,0x12a8,8,
NtGdiEngFillPath=0x2e,0x12a9,7,
NtGdiEngStrokeAndFillPath=0x2e,0x12aa,10,
NtGdiEngPaint=0x2e,0x12ab,5,
NtGdiEngLineTo=0x2e,0x12ac,9,
NtGdiEngAlphaBlend=0x2e,0x12ad,7,
NtGdiEngGradientFill=0x2e,0x12ae,10,
NtGdiEngTransparentBlt=0x2e,0x12af,8,
NtGdiEngTextOut=0x2e,0x12b0,10,
NtGdiEngStretchBltROP=0x2e,0x12b1,13,
NtGdiXLATEOBJ_cGetPalette=0x2e,0x12b2,4,
NtGdiXLATEOBJ_iXlate=0x2e,0x12b3,2,
NtGdiXLATEOBJ_hGetColorTransform=0x2e,0x12b4,1,
NtGdiCLIPOBJ_bEnum=0x2e,0x12b5,3,
NtGdiCLIPOBJ_cEnumStart=0x2e,0x12b6,5,
NtGdiCLIPOBJ_ppoGetPath=0x2e,0x12b7,1,
NtGdiEngDeletePath=0x2e,0x12b8,1,
NtGdiEngCreateClip=0x2e,0x12b9,0,
NtGdiEngDeleteClip=0x2e,0x12ba,1,
NtGdiBRUSHOBJ_ulGetBrushColor=0x2e,0x12bb,1,
NtGdiBRUSHOBJ_pvAllocRbrush=0x2e,0x12bc,2,
NtGdiBRUSHOBJ_pvGetRbrush=0x2e,0x12bd,1,
NtGdiBRUSHOBJ_hGetColorTransform=0x2e,0x12be,1,
NtGdiXFORMOBJ_bApplyXform=0x2e,0x12bf,5,
NtGdiXFORMOBJ_iGetXform=0x2e,0x12c0,2,
NtGdiFONTOBJ_vGetInfo=0x2e,0x12c1,3,
NtGdiFONTOBJ_pxoGetXform=0x2e,0x12c2,1,
NtGdiFONTOBJ_cGetGlyphs=0x2e,0x12c3,5,
NtGdiFONTOBJ_pifi=0x2e,0x12c4,1,
NtGdiFONTOBJ_pfdg=0x2e,0x12c5,1,
NtGdiFONTOBJ_pQueryGlyphAttrs=0x2e,0x12c6,2,
NtGdiFONTOBJ_pvTrueTypeFontFile=0x2e,0x12c7,2,
NtGdiFONTOBJ_cGetAllGlyphPlugins=0x2e,0x12c8,2,
NtGdiSTROBJ_bEnum=0x2e,0x12c9,3,
NtGdiSTROBJ_bEnumPositionsOnly=0x2e,0x12ca,3,
NtGdiSTROBJ_bGetAdvanceWidths=0x2e,0x12cb,4,
NtGdiSTROBJ_vEnumStart=0x2e,0x12cc,1,
NtGdiSTROBJ_dwGetCodePage=0x2e,0x12cd,1,
NtGdiPATHOBJ_vGetBounds=0x2e,0x12ce,2,
NtGdiPATHOBJ_bEnum=0x2e,0x12cf,2,
NtGdiPATHOBJ_vEnumStart=0x2e,0x12d0,1,
NtGdiPATHOBJ_vEnumStartClipLines=0x2e,0x12d1,4,
NtGdiPATHOBJ_bEnumClipLines=0x2e,0x12d2,3,
NtGdiGetDhpdev=0x2e,0x12d3,1,
NtGdiEngCheckAbort=0x2e,0x12d4,1,
NtGdiHT_Get8BPPFormatPalette=0x2e,0x12d5,4,
NtGdiHT_Get8BPPMaskPalette=0x2e,0x12d6,6,
NtGdiUpdateTransform=0x2e,0x12d7,1,
NtGdiSetPUMPDOBJ=0x2e,0x12d8,4,
NtGdiBRUSHOBJ_DeleteRbrush=0x2e,0x12d9,2,
NtGdiUMPDEngFreeUserMem=0x2e,0x12da,1,
NtGdiDrawStream=0x2e,0x12db,3,
NtGdiSfmGetNotificationTokens=0x2e,0x12dc,3,
NtGdiHLSurfGetInformation=0x2e,0x12dd,4,
NtGdiHLSurfSetInformation=0x2e,0x12de,4,
NtGdiDdDDICreateAllocation=0x2e,0x12df,1,
NtGdiDdDDIQueryResourceInfo=0x2e,0x12e0,1,
NtGdiDdDDIOpenResource=0x2e,0x12e1,1,
NtGdiDdDDIDestroyAllocation=0x2e,0x12e2,1,
NtGdiDdDDISetAllocationPriority=0x2e,0x12e3,1,
NtGdiDdDDIQueryAllocationResidency=0x2e,0x12e4,1,
NtGdiDdDDICreateDevice=0x2e,0x12e5,1,
NtGdiDdDDIDestroyDevice=0x2e,0x12e6,1,
NtGdiDdDDICreateContext=0x2e,0x12e7,1,
NtGdiDdDDIDestroyContext=0x2e,0x12e8,1,
NtGdiDdDDICreateSynchronizationObject=0x2e,0x12e9,1,
NtGdiDdDDIOpenSynchronizationObject=0x2e,0x12ea,1,
NtGdiDdDDIDestroySynchronizationObject=0x2e,0x12eb,1,
NtGdiDdDDIWaitForSynchronizationObject=0x2e,0x12ec,1,
NtGdiDdDDISignalSynchronizationObject=0x2e,0x12ed,1,
NtGdiDdDDIGetRuntimeData=0x2e,0x12ee,1,
NtGdiDdDDIQueryAdapterInfo=0x2e,0x12ef,1,
NtGdiDdDDILock=0x2e,0x12f0,1,
NtGdiDdDDIUnlock=0x2e,0x12f1,1,
NtGdiDdDDIGetDisplayModeList=0x2e,0x12f2,1,
NtGdiDdDDISetDisplayMode=0x2e,0x12f3,1,
NtGdiDdDDIGetMultisampleMethodList=0x2e,0x12f4,1,
NtGdiDdDDIPresent=0x2e,0x12f5,1,
NtGdiDdDDIRender=0x2e,0x12f6,1,
NtGdiDdDDIOpenAdapterFromDeviceName=0x2e,0x12f7,1,
NtGdiDdDDIOpenAdapterFromHdc=0x2e,0x12f8,1,
NtGdiDdDDICloseAdapter=0x2e,0x12f9,1,
NtGdiDdDDIGetSharedPrimaryPlugin=0x2e,0x12fa,1,
NtGdiDdDDIEscape=0x2e,0x12fb,1,
NtGdiDdDDIQueryStatistics=0x2e,0x12fc,1,
NtGdiDdDDISetVidPnSourceOwner=0x2e,0x12fd,1,
NtGdiDdDDIGetPresentHistory=0x2e,0x12fe,1,
NtGdiDdDDIGetPresentQueueEvent=0x2e,0x12ff,2,
NtGdiDdDDICreateOverlay=0x2e,0x1300,1,
NtGdiDdDDIUpdateOverlay=0x2e,0x1301,1,
NtGdiDdDDIFlipOverlay=0x2e,0x1302,1,
NtGdiDdDDIDestroyOverlay=0x2e,0x1303,1,
NtGdiDdDDIWaitForVerticalBlankEvent=0x2e,0x1304,1,
NtGdiDdDDISetGammaRamp=0x2e,0x1305,1,
NtGdiDdDDIGetDeviceState=0x2e,0x1306,1,
NtGdiDdDDICreateDCFromMemory=0x2e,0x1307,1,
NtGdiDdDDIDestroyDCFromMemory=0x2e,0x1308,1,
NtGdiDdDDISetContextSchedulingPriority=0x2e,0x1309,1,
NtGdiDdDDIGetContextSchedulingPriority=0x2e,0x130a,1,
NtGdiDdDDISetProcessSchedulingPriorityClass=0x2e,0x130b,2,
NtGdiDdDDIGetProcessSchedulingPriorityClass=0x2e,0x130c,2,
NtGdiDdDDIReleaseProcessVidPnSourceOwners=0x2e,0x130d,1,
NtGdiDdDDIGetScanLine=0x2e,0x130e,1,
NtGdiDdDDISetQueuedLimit=0x2e,0x130f,1,
NtGdiDdDDIPollDisplayChildren=0x2e,0x1310,1,
NtGdiDdDDIInvalidateActiveVidPn=0x2e,0x1311,1,
NtGdiDdDDICheckOcclusion=0x2e,0x1312,1,
NtGdiDdDDIWaitForIdle=0x2e,0x1313,1,
NtGdiDdDDICheckMonitorPowerState=0x2e,0x1314,1,
NtGdiDdDDICheckExclusiveOwnership=0x2e,0x1315,0,
NtGdiDdDDISetDisplayPrivateDriverFormat=0x2e,0x1316,1,
NtGdiDdDDISharedPrimaryLockNotification=0x2e,0x1317,1,
NtGdiDdDDISharedPrimaryUnLockNotification=0x2e,0x1318,1,
NtGdiDdDDICreateKeyedMutex=0x2e,0x1319,1,
NtGdiDdDDIOpenKeyedMutex=0x2e,0x131a,1,
NtGdiDdDDIDestroyKeyedMutex=0x2e,0x131b,1,
NtGdiDdDDIAcquireKeyedMutex=0x2e,0x131c,1,
NtGdiDdDDIReleaseKeyedMutex=0x2e,0x131d,1,
NtGdiDdDDIConfigureSharedResource=0x2e,0x131e,1,
NtGdiDdDDIGetOverlayState=0x2e,0x131f,1,
NtGdiDdDDICheckVidPnExclusiveOwnership=0x2e,0x1320,1,
NtGdiDdDDICheckSharedResourceAccess=0x2e,0x1321,1,
DxgStubEndMoCompFrame=0x2e,0x1322,2,
DxgStubContextDestroyAll=0x2e,0x1323,1,
NtGdiGetNumberOfPhysicalMonitors=0x2e,0x1324,2,
NtGdiGetPhysicalMonitors=0x2e,0x1325,4,
NtGdiGetPhysicalMonitorDescription=0x2e,0x1326,3,
NtGdiDestroyPhysicalMonitor=0x2e,0x1327,1,
NtGdiDDCCIGetVCPFeature=0x2e,0x1328,5,
NtGdiDDCCISetVCPFeature=0x2e,0x1329,3,
NtGdiDDCCISaveCurrentSettings=0x2e,0x132a,1,
NtGdiDDCCIGetCapabilitiesStringLength=0x2e,0x132b,2,
NtGdiDDCCIGetCapabilitiesString=0x2e,0x132c,3,
NtGdiDDCCIGetTimingReport=0x2e,0x132d,2,
NtGdiDdCreateFullscreenSprite=0x2e,0x132e,4,
NtGdiDdNotifyFullscreenSpriteUpdate=0x2e,0x132f,2,
NtGdiDdDestroyFullscreenSprite=0x2e,0x1330,2,
DxEngVisRgnUniq=0x2e,0x1331,0,
NtUserSetMirrorRendering=0x2e,0x1332,2,
NtUserShowSystemCursor=0x2e,0x1333,1,
NtUserMagControl=0x2e,0x1334,2,
NtUserMagSetContextInformation=0x2e,0x1335,4,
NtUserMagGetContextInformation=0x2e,0x1336,4,
NtUserHwndQueryRedirectionInfo=0x2e,0x1337,4,
NtUserHwndSetRedirectionInfo=0x2e,0x1338,4,
rizin-0.7.4/librz/syscall/d/ios-x86-32.sdb.txt 0000664 0001750 0001750 00000015730 14731035230 020211 0 ustar sophie sophie _=0x81
exit=0x81,1,1,
fork=0x81,2,0
read=0x81,3,3,
write=0x81,4,3,
open=0x81,5,3,
close=0x81,6,1,
wait4=0x81,7,3,
link=0x81,9,2,zz
unlink=0x81,10,1,z
chdir=0x81,12,1,z
fchdir=0x81,13,1,i
mknod=0x81,14,3,zii
chmod=0x81,15,2,zi
chown=0x81,16,3,zii
getfsstat=0x81,18,3,pii
getpid=0x81,20,0,
setuid=0x81,23,1,i
getuid=0x81,24,0,
geteuid=0x81,25,0,
ptrace=0x81,26,4,
recvmsg=0x81,27,3,
sendmsg=0x81,28,3,
recvfrom=0x81,29,3,
accept=0x81,30,1,i
getpeername=0x81,31,0,
getsockname=0x81,32,0,
access=0x81,33,0,
chflags=0x81,34,0
fchflags=0x81,35,0
sync=0x81,36,0
kill=0x81,37,0
getppid=0x81,39,0
dup=0x81,41,0
pipe=0x81,42,0
getegid=0x81,43,0
sigaction=0x81,46,0
getgid=0x81,47,0
sigprocmask=0x81,48,0
getlogin=0x81,49,0
setlogin=0x81,50,0
acct=0x81,51,0
sigpending=0x81,52,0
sigaltstack=0x81,53,0
ioctl=0x81,54,0
reboot=0x81,55,0
revoke=0x81,56,0
symlink=0x81,57,0
readlink=0x81,58,0
execve=0x81,59,0
umask=0x81,60,0
chroot=0x81,61,0
msync=0x81,65,0
vfork=0x81,66,0
munmap=0x81,73,0
mprotect=0x81,74,0
madvise=0x81,75,0
mincore=0x81,78,0
getgroups=0x81,79,0
setgroups=0x81,80,0
getpgrp=0x81,81,0
setpgid=0x81,82,0
setitimer=0x81,83,0
swapon=0x81,85,0
getitimer=0x81,86,0
getdtablesize=0x81,89,0
dup2=0x81,90,0
fcntl=0x81,92,0
select=0x81,93,0
fsync=0x81,95,0
setpriority=0x81,96,0
socket=0x81,97,0
connect=0x81,98,0
getpriority=0x81,100,0
bind=0x81,104,0
setsockopt=0x81,105,0
listen=0x81,106,0
sigsuspend=0x81,111,0
gettimeofday=0x81,116,0
getrusage=0x81,117,0
getsockopt=0x81,118,0
readv=0x81,120,0
writev=0x81,121,0
settimeofday=0x81,122,0
fchown=0x81,123,0
fchmod=0x81,124,0
setreuid=0x81,126,0
setregid=0x81,127,0
rename=0x81,128,0
flock=0x81,131,0
mkfifo=0x81,132,0
sendto=0x81,133,0
shutdown=0x81,134,0
socketpair=0x81,135,0
mkdir=0x81,136,0
rmdir=0x81,137,0
utimes=0x81,138,0
futimes=0x81,139,0
adjtime=0x81,140,0
gethostuuid=0x81,142,0
setsid=0x81,147,0
getpgid=0x81,151,0
setprivexec=0x81,152,0
pread=0x81,153,0
pwrite=0x81,154,0
statfs=0x81,157,0
fstatfs=0x81,158,0
unmount=0x81,159,0
quotactl=0x81,165,0
mount=0x81,167,0
csops=0x81,169,0
170=0x81,170,0
waitid=0x81,173,0
kdebug_trace=0x81,180,0
setgid=0x81,181,0
setegid=0x81,182,0
seteuid=0x81,183,0
sigreturn=0x81,184,0
chud=0x81,185,0
fdatasync=0x81,187,0
stat=0x81,188,0
fstat=0x81,189,0
lstat=0x81,190,0
pathconf=0x81,191,0
fpathconf=0x81,192,0
getrlimit=0x81,194,0
setrlimit=0x81,195,0
getdirentries=0x81,196,0
mmap=0x81,197,0
lseek=0x81,199,0
truncate=0x81,200,0
ftruncate=0x81,201,0
__sysctl=0x81,202,0
mlock=0x81,203,0
munlock=0x81,204,0
undelete=0x81,205,0
mkcomplex=0x81,216,0
getattrlist=0x81,220,0
setattrlist=0x81,221,0
getdirentriesattr=0x81,222,0
exchangedata=0x81,223,0
searchfs=0x81,225,0
delete=0x81,226,0
copyfile=0x81,227,0
fgetattrlist=0x81,228,0
fsetattrlist=0x81,229,0
poll=0x81,230,0
watchevent=0x81,231,0
waitevent=0x81,232,0
modwatch=0x81,233,0
getxattr=0x81,234,0
fgetxattr=0x81,235,0
setxattr=0x81,236,0
fsetxattr=0x81,237,0
removexattr=0x81,238,0
fremovexattr=0x81,239,0
listxattr=0x81,240,0
flistxattr=0x81,241,0
fsctl=0x81,242,0
initgroups=0x81,243,0
posix_spawn=0x81,244,0
ffsctl=0x81,245,0
minherit=0x81,250,0
shm_open=0x81,266,0
shm_unlink=0x81,267,0
sem_open=0x81,268,0
sem_close=0x81,269,0
sem_unlink=0x81,270,0
sem_wait=0x81,271,0
sem_trywait=0x81,272,0
sem_post=0x81,273,0
sem_getvalue=0x81,274,0
sem_init=0x81,275,0
sem_destroy=0x81,276,0
open_extended=0x81,277,0
umask_extended=0x81,278,0
stat_extended=0x81,279,0
lstat_extended=0x81,280,0
fstat_extended=0x81,281,0
chmod_extended=0x81,282,0
fchmod_extended=0x81,283,0
access_extended=0x81,284,0
settid=0x81,285,0
gettid=0x81,286,0
setsgroups=0x81,287,0
getsgroups=0x81,288,0
setwgroups=0x81,289,0
getwgroups=0x81,290,0
mkfifo_extended=0x81,291,0
mkdir_extended=0x81,292,0
shared_region_check_np=0x81,294,0
vm_pressure_monitor=0x81,296,0
psynch_rw_longrdlock=0x81,297,0
psynch_rw_yieldwrlock=0x81,298,0
psynch_rw_downgrade=0x81,299,0
psynch_rw_upgrade=0x81,300,0
psynch_mutexwait=0x81,301,0
psynch_mutexdrop=0x81,302,0
psynch_cvbroad=0x81,303,0
psynch_cvsignal=0x81,304,0
psynch_cvwait=0x81,305,0
psynch_rw_rdlock=0x81,306,0
psynch_rw_wrlock=0x81,307,0
psynch_rw_unlock=0x81,308,0
psynch_rw_unlock2=0x81,309,0
getsid=0x81,310,0
settid_with_pid=0x81,311,0
psynch_cvclrprepost=0x81,312,0
aio_fsync=0x81,313,0
aio_return=0x81,314,0
aio_suspend=0x81,315,0
aio_cancel=0x81,316,0
aio_error=0x81,317,0
aio_read=0x81,318,0
aio_write=0x81,319,0
lio_listio=0x81,320,0
iopolicysys=0x81,322,0
process_policy=0x81,323,0
mlockall=0x81,324,0
munlockall=0x81,325,0
issetugid=0x81,327,0
__pthread_kill=0x81,328,0
__pthread_sigmask=0x81,329,0
__sigwait=0x81,330,0
__disable_threadsignal=0x81,331,0
__pthread_markcancel=0x81,332,0
__pthread_canceled=0x81,333,0
__semwait_signal=0x81,334,0
proc_info=0x81,336,0
stat64=0x81,338,0
fstat64=0x81,339,0
lstat64=0x81,340,0
stat64_extended=0x81,341,0
lstat64_extended=0x81,342,0
fstat64_extended=0x81,343,0
getdirentries64=0x81,344,0
statfs64=0x81,345,0
fstatfs64=0x81,346,0
getfsstat64=0x81,347,0
__pthread_chdir=0x81,348,0
__pthread_fchdir=0x81,349,0
audit=0x81,350,0
auditon=0x81,351,0
getauid=0x81,353,0
setauid=0x81,354,0
getaudit_addr=0x81,357,0
setaudit_addr=0x81,358,0
auditctl=0x81,359,0
bsdthread_create=0x81,360,0
bsdthread_terminate=0x81,361,0
kqueue=0x81,362,0
kevent=0x81,363,0
lchown=0x81,364,0
stack_snapshot=0x81,365,0
bsdthread_register=0x81,366,0
workq_open=0x81,367,0
workq_kernreturn=0x81,368,0
kevent64=0x81,369,7,
__old_semwait_signal=0x81,370,0
__old_semwait_signal_nocancel=0x81,371,0
thread_selfid=0x81,372,0
ledger=0x81,373,0
__mac_execve=0x81,380,0
__mac_syscall=0x81,381,0
__mac_get_file=0x81,382,0
__mac_set_file=0x81,383,0
__mac_get_link=0x81,384,0
__mac_set_link=0x81,385,0
__mac_get_proc=0x81,386,0
__mac_set_proc=0x81,387,0
__mac_get_fd=0x81,388,0
__mac_set_fd=0x81,389,0
__mac_get_pid=0x81,390,0
__mac_get_lcid=0x81,391,0
__mac_get_lctx=0x81,392,0
__mac_set_lctx=0x81,393,0
setlcid=0x81,394,0
getlcid=0x81,395,0
read_nocancel=0x81,396,0
write_nocancel=0x81,397,0
open_nocancel=0x81,398,0
close_nocancel=0x81,399,0
wait4_nocancel=0x81,400,0
recvmsg_nocancel=0x81,401,0
sendmsg_nocancel=0x81,402,0
recvfrom_nocancel=0x81,403,0
accept_nocancel=0x81,404,0
msync_nocancel=0x81,405,0
fcntl_nocancel=0x81,406,0
select_nocancel=0x81,407,0
fsync_nocancel=0x81,408,0
connect_nocancel=0x81,409,0
sigsuspend_nocancel=0x81,410,0
readv_nocancel=0x81,411,0
writev_nocancel=0x81,412,0
sendto_nocancel=0x81,413,0
pread_nocancel=0x81,414,0
pwrite_nocancel=0x81,415,0
waitid_nocancel=0x81,416,0
poll_nocancel=0x81,417,0
sem_wait_nocancel=0x81,420,0
aio_suspend_nocancel=0x81,421,0
__sigwait_nocancel=0x81,422,0
__semwait_signal_nocancel=0x81,423,0
__mac_mount=0x81,424,0
__mac_get_mount=0x81,425,0
__mac_getfsstat=0x81,426,0
fsgetpath=0x81,427,0
audit_session_self=0x81,428,0
audit_session_join=0x81,429,0
fileport_makeport=0x81,430,0
fileport_makefd=0x81,431,0
audit_session_port=0x81,432,0
pid_suspend=0x81,433,0
pid_resume=0x81,434,0
pid_hibernate=0x81,435,0
pid_shutdown_sockets=0x81,436,0
shared_region_map_and_slide_np=0x81,438,0
kas_info=0x81,439,0
memorystatus_control=0x81,440,0
guarded_open_np=0x81,441,0
guarded_close_np=0x81,442,0
rizin-0.7.4/librz/syscall/d/meson.build 0000664 0001750 0001750 00000001715 14731035230 017402 0 ustar sophie sophie sdb_files = [
'darwin-arm-32',
'darwin-arm-64',
'darwin-x86-32',
'darwin-x86-64',
'dos-x86-16',
'freebsd-x86-32',
'ios-arm-32',
'ios-arm-64',
'ios-x86-32',
'linux-arm-32',
'linux-arm-64',
'linux-mips-32',
'linux-sparc-32',
'linux-x86-32',
'linux-x86-64',
'netbsd-x86-32',
'openbsd-x86-32',
'openbsd-x86-64',
's110-arm-16',
'windows-x86-32',
'windows-x86-64',
]
foreach file : sdb_files
tmp_outfile = '@0@.sdb.txt.tmp'.format(file)
pre_sdb_txt = custom_target(tmp_outfile,
input: '@0@.sdb.txt'.format(file),
output: tmp_outfile,
command: [py3_exe, syscall_preprocessing_py, '@INPUT@', '@OUTPUT@'],
build_by_default: true,
install: false
)
outfile = '@0@.sdb'.format(file)
custom_target(outfile,
input: pre_sdb_txt,
output: outfile,
command: sdb_gen_cmd,
depends: sdb_exe,
build_by_default: true,
install: true,
install_dir: join_paths(rizin_sdb, 'syscall')
)
endforeach
rizin-0.7.4/librz/syscall/d/linux-sparc-32.sdb.txt 0000664 0001750 0001750 00000001154 14731035230 021234 0 ustar sophie sophie _=0x10
exit=0x10,1,1,i
fork=0x10,2,0,
read=0x10,3,3,ipi
write=0x10,4,3,izi
open=0x10,5,3,zxx
close=0x10,6,1,i
waitpid=0x10,7,3,ipx
creat=0x10,8,2,zx
link=0x10,9,2,zz
unlink=0x10,10,1,z
execve=0x10,11,3,zzz
chdir=0x10,12,1,z
getpid=0x10,20,0,
setuid=0x10,23,1,i
getuid=0x10,24,0,
ptrace=0x10,26,4,
utime=0x10,30,2,
access=0x10,33,2,
kill=0x10,37,2,
dup=0x10,41,2,
brk=0x10,45,1,
signal=0x10,48,2,
ioctl=0x10,54,3,
mmap=0x10,90,6,
munmap=0x10,91,1,
socketcall=0x10,102,2,
sigreturn=0x10,119,1,
clone=0x10,120,4,
mprotect=0x10,125,3,
rt_sigaction=0x10,174,3,
rt_sigprocmask=0x10,175,3,
sysctl=0x10,149,1,
mmap2=0x10,192,6,
rizin-0.7.4/librz/syscall/d/gen.sh 0000775 0001750 0001750 00000000264 14731035230 016346 0 ustar sophie sophie #!/bin/sh
#echo "_=0x80"
awk -F '(=|,)' '{
# 0x80.1=exit
if ($1 == "_") {
print $1"="$2
} else {
print $2"."$3"="$1
# exit=0x80,1,1,i
print $1"="$2","$3","$4","$5
}
}'
rizin-0.7.4/librz/syscall/d/netbsd-x86-32.sdb.txt 0000664 0001750 0001750 00000001704 14731035230 020672 0 ustar sophie sophie _=0x80
syscall=0x80,0,4,
exit=0x80,1,1,
fork=0x80,2,0,
read=0x80,3,3,
write=0x80,4,3,
open=0x80,5,3,
close=0x80,6,1,
wait4=0x80,7,3,
compat_43_ocreat=0x80,8,2,
link=0x80,9,2,
unlink=0x80,10,1,
//=execve,0x80,11,3
chdir=0x80,12,1,
fchdir=0x80,13,1,
mknod=0x80,14,1,
chmod=0x80,15,1,
chown=0x80,16,1,
break=0x80,17,1,
getpid=0x80,20,0,
mount=0x80,21,0,
unmount=0x80,22,0,
setuid=0x80,23,1,
getuid=0x80,24,0,
ptrace=0x80,26,4,
recvmsg=0x80,27,4,
sendmsg=0x80,28,4,
recvfrom=0x80,29,4,
accept=0x80,30,4,
access=0x80,33,2,
dup=0x80,41,2,
ktrace=0x80,45,1,
signal=0x80,48,2,
utime=0x80,30,2,
kill=0x80,37,2,
ioctl=0x80,54,3,
mmap=0x80,90,6,
munmap=0x80,91,1,
socketcall=0x80,102,2,
sigreturn=0x80,119,1,
clone=0x80,120,4,
mprotect=0x80,125,3,
rt_sigaction=0x80,174,3,
rt_sigprocmask=0x80,175,3,
sysctl=0x80,149,1,
mmap2=0x80,192,6,
fstat64=0x80,197,2,
fcntl64=0x80,221,3,
gettid=0x80,224,0,
set_thread_area=0x80,243,2,
get_thread_area=0x80,244,2,
exit_group=0x80,252,1,
rizin-0.7.4/librz/syscall/d/s110-arm-16.sdb.txt 0000664 0001750 0001750 00000010321 14731035230 020226 0 ustar sophie sophie _=-1
application_0=0,0
application_1=1,0
application_2=2,0
application_3=3,0
application_4=4,0
application_5=5,0
application_6=6,0
application_7=7,7
application_8=8,0
application_9=9,0
application_10=10,0
application_11=11,0
application_12=12,0
application_13=13,0
application_14=14,0
application_15=15,0
sd_softdevice_enable=0x10,0
sd_softdevice_disable=0x11,0
sd_softdevice_is_enabled=0x12,0,1
sd_softdevice_vector_table_base_set=0x13,0,1
sd_mbr_command=0x14,0,1
sd_ppi_channel_enable_get=0x20,0,1
sd_ppi_channel_enable_set=0x21,0,1
sd_ppi_channel_enable_clr=0x22,0,1
sd_ppi_channel_assign=0x23,0,3
sd_ppi_group_task_enable=0x24,0,1
sd_ppi_group_task_disable=0x25,0,1
sd_ppi_group_assign=0x26,0,2
sd_ppi_group_get=0x27,0,2
sd_flash_page_erase=0x28,0,1
sd_flash_write=0x29,0,3
sd_flash_protect=0x2a,0,2
sd_mutex_new=0x2b,0,1
sd_mutex_acquire=0x2c,0,1
sd_mutex_release=0x2d,0,1
sd_nvic_enableirq=0x2e,0,1
sd_nvic_disableirq=0x2f,0,1
sd_nvic_getpendingirq=0x30,0,2
sd_nvic_setpendingirq=0x31,0,1
sd_nvic_clearpendingirq=0x32,0,1
sd_nvic_setpriority=0x33,0,1
sd_nvic_getpriority=0x34,0,2
sd_nvic_systemreset=0x35,0,2
sd_nvic_critical_region_enter=0x36,0,1
sd_nvic_critical_region_exit=0x37,0,1
sd_rand_application_pool_capacity=0x38,0,1
sd_rand_application_bytes_available=0x39,0,1
sd_rand_application_get_vector=0x3a,0,2
sd_power_mode_set=0x3b,0,1
sd_power_system_off=0x3c,0
sd_power_reset_reason_get=0x3d,0,1
sd_power_reset_reason_clr=0x3e,0,1
sd_power_pof_enable=0x3f,0,1
sd_power_pof_threshold_set=0x40,0,1
sd_power_ramon_set=0x41,0,1
sd_power_ramon_clr=0x42,0,1
sd_power_ramon_get=0x43,0,1
sd_power_gpregret_set=0x44,0,1
sd_power_gpregret_clr=0x45,0,1
sd_power_gpregret_get=0x46,0,1
sd_power_dcdc_mode_set=0x47,0,1
sd_app_evt_wait=0x48,0
sd_clock_hfclk_request=0x49,0
sd_clock_hfclk_release=0x4a,0
sd_clock_hfclk_is_running=0x4b,0,1
sd_radio_notification_cfg_set=0x4c,0,2
sd_ecb_block_encrypt=0x4d,0,1
sd_radio_session_open=0x4e,0,1
sd_radio_session_close=0x4f,0
sd_radio_request=0x50,0,1
sd_evt_get=0x51,0,1
sd_temp_get=0x52,0,1
sd_ble_enable=0x60,0,1
sd_ble_evt_get=0x61,0,2
sd_ble_tx_buffer_count_get=0x62,0,1
sd_ble_uuid_vs_add=0x63,0,2
sd_ble_uuid_decode=0x64,0,3
sd_ble_uuid_encode=0x65,0,3
sd_ble_version_get=0x66,0,1
sd_ble_user_mem_reply=0x67,0,2
sd_ble_opt_set=0x68,0,2
sd_ble_opt_get=0x69,0,2
sd_ble_gap_address_set=0x70,0,2
sd_ble_gap_address_get=0x71,0,1
sd_ble_gap_adv_data_set=0x72,0,4
sd_ble_gap_adv_start=0x73,0,1
sd_ble_gap_adv_stop=0x74,0
sd_ble_gap_conn_param_update=0x75,0,2
sd_ble_gap_disconnect=0x76,0,2
sd_ble_gap_tx_power_set=0x77,0,1
sd_ble_gap_appearance_set=0x78,0,1
sd_ble_gap_appearance_get=0x79,0,1
sd_ble_gap_ppcp_set=0x7a,0,1
sd_ble_gap_ppcp_get=0x7b,0,1
sd_ble_gap_device_name_set=0x7c,0,3
sd_ble_gap_device_name_get=0x7d,0,2
sd_ble_gap_authenticate=0x7e,0,2
sd_ble_gap_sec_params_reply=0x7f,0,4
sd_ble_gap_auth_key_reply=0x80,0,3
sd_ble_gap_encrypt=0x81,0,3
sd_ble_gap_sec_info_reply=0x82,0,4
sd_ble_gap_conn_sec_get=0x83,0,2
sd_ble_gap_rssi_start=0x84,0,3
sd_ble_gap_rssi_stop=0x85,0,1
sd_ble_gap_scan_start=0x86,0,1
sd_ble_gap_scan_stop=0x87,0
sd_ble_gap_connect=0x88,0,3
sd_ble_gap_connect_cancel=0x89,0
sd_ble_gap_rssi_get=0x8a,0,2
sd_ble_gattc_primary_services_discover=0x90,0,3
sd_ble_gattc_relationships_discover=0x91,0,2
sd_ble_gattc_characteristics_discover=0x92,0,2
sd_ble_gattc_descriptors_discover=0x93,0,2
sd_ble_gattc_char_value_by_uuid_read=0x94,0,3
sd_ble_gattc_read=0x95,0,3
sd_ble_gattc_char_values_read=0x96,0,3
sd_ble_gattc_write=0x97,0,2
sd_ble_gattc_hv_confirm=0x98,0,2
sd_ble_gatts_service_add=0xa0,0,3
sd_ble_gatts_include_add=0xa1,0,3
sd_ble_gatts_characteristic_add=0xa2,0,4
sd_ble_gatts_descriptor_add=0xa3,0,3
sd_ble_gatts_value_set=0xa4,0,3
sd_ble_gatts_value_get=0xa5,0,3
sd_ble_gatts_hvx=0xa6,0,2
sd_ble_gatts_service_changed=0xa7,0,3
sd_ble_gatts_rw_authorize_reply=0xa8,0,2
sd_ble_gatts_sys_attr_set=0xa9,0,4
sd_ble_gatts_sys_attr_get=0xaa,0,4
sd_ble_l2cap_cid_register=0xb0,0,1
sd_ble_l2cap_cid_unregister=0xb1,0,1
sd_ble_l2cap_tx=0xb2,0,3
sd_ble_l2cap_4=0xb3,0
sd_ble_l2cap_5=0xb4,0
sd_ble_l2cap_6=0xb5,0
sd_ble_l2cap_7=0xb6,0
sd_ble_l2cap_8=0xb7,0
sd_ble_l2cap_9=0xb8,0
sd_ble_l2cap_10=0xb9,0
sd_ble_l2cap_11=0xba,0
sd_ble_l2cap_12=0xbb,0
sd_ble_l2cap_13=0xbe,0
sd_ble_l2cap_14=0xbd,0
sd_ble_l2cap_15=0xbe,0
sd_ble_l2cap_16=0xbf,0
rizin-0.7.4/librz/syscall/d/linux-arm-32.sdb.txt 0000664 0001750 0001750 00000002012 14731035230 020675 0 ustar sophie sophie _=0x900000
exit=0x900000,1,1,i
fork=0x900000,2,0,
read=0x900000,3,3,ipi
write=0x900000,4,3,izi
open=0x900000,5,3,zxx
close=0x900000,6,1,i
waitpid=0x900000,7,3,ipx
creat=0x900000,8,2,zx
link=0x900000,9,2,zz
unlink=0x900000,10,1,z
execve=0x900000,11,3,zzz
chdir=0x900000,12,1,z
time=0x900000,13,1,p
mknod=0x900000,14,1,zxi
chmod=0x900000,15,1,zx
lchown=0x900000,16,1,zii
getpid=0x900000,20,0,
setuid=0x900000,23,1,i
getuid=0x900000,24,0,
ptrace=0x900000,26,4,
utime=0x900000,30,2,
access=0x900000,33,2,
kill=0x900000,37,2,
dup=0x900000,41,2,
brk=0x900000,45,1,
signal=0x900000,48,2,
ioctl=0x900000,54,3,
mmap=0x900000,90,6,
munmap=0x900000,91,1,
socketcall=0x900000,102,2,
sigreturn=0x900000,119,1,
clone=0x900000,120,4,
mprotect=0x900000,125,3,
rt_sigaction=0x900000,174,3,
rt_sigprocmask=0x900000,175,3,
sysctl=0x900000,149,1,
vfork=0x900000,1071,0,
mmap2=0x900000,192,6,
fstat64=0x900000,197,2,
fcntl64=0x900000,221,3,
gettid=0x900000,224,0,
set_thread_area=0x900000,243,2,
get_thread_area=0x900000,244,2,
exit_group=0x900000,252,1,
rizin-0.7.4/librz/syscall/d/darwin-x86-32.sdb.txt 0000664 0001750 0001750 00000030266 14731035230 020704 0 ustar sophie sophie _=0x80
exit=0x80,0x1,1,
fork=0x80,0x2,0,
read=0x80,0x3,3,
write=0x80,0x4,3,
open=0x80,0x5,3,
close=0x80,0x6,1,
wait4=0x80,0x7,4,
link=0x80,0x9,2,
unlink=0x80,0xa,1,
chdir=0x80,0xc,1,
fchdir=0x80,0xd,1,
mknod=0x80,0xe,3,
chmod=0x80,0xf,2,
chown=0x80,0x10,3,
getfsstat=0x80,0x12,3,
getpid=0x80,0x14,0,
setuid=0x80,0x17,1,
getuid=0x80,0x18,0,
geteuid=0x80,0x19,0,
ptrace=0x80,0x1a,4,
recvmsg=0x80,0x1b,3,
sendmsg=0x80,0x1c,3,
recvfrom=0x80,0x1d,6,
accept=0x80,0x1e,3,
getpeername=0x80,0x1f,3,
getsockname=0x80,0x20,3,
access=0x80,0x21,2,
chflags=0x80,0x22,2,
fchflags=0x80,0x23,2,
sync=0x80,0x24,0,
kill=0x80,0x25,3,
getppid=0x80,0x27,0,
dup=0x80,0x29,1,
pipe=0x80,0x2a,0,
getegid=0x80,0x2b,0,
sigaction=0x80,0x2e,3,
getgid=0x80,0x2f,0,
sigprocmask=0x80,0x30,3,
getlogin=0x80,0x31,2,
setlogin=0x80,0x32,1,
acct=0x80,0x33,1,
sigpending=0x80,0x34,1,
sigaltstack=0x80,0x35,2,
ioctl=0x80,0x36,3,
reboot=0x80,0x37,2,
revoke=0x80,0x38,1,
symlink=0x80,0x39,2,
readlink=0x80,0x3a,3,
execve=0x80,0x3b,3,
umask=0x80,0x3c,1,
chroot=0x80,0x3d,1,
msync=0x80,0x41,3,
vfork=0x80,0x42,0,
munmap=0x80,0x49,2,
mprotect=0x80,0x4a,3,
madvise=0x80,0x4b,3,
mincore=0x80,0x4e,3,
getgroups=0x80,0x4f,2,
setgroups=0x80,0x50,2,
getpgrp=0x80,0x51,0,
setpgid=0x80,0x52,2,
setitimer=0x80,0x53,3,
swapon=0x80,0x55,0,
getitimer=0x80,0x56,2,
getdtablesize=0x80,0x59,0,
dup2=0x80,0x5a,2,
fcntl=0x80,0x5c,3,
select=0x80,0x5d,5,
fsync=0x80,0x5f,1,
setpriority=0x80,0x60,3,
socket=0x80,0x61,3,
connect=0x80,0x62,3,
getpriority=0x80,0x64,2,
bind=0x80,0x68,3,
setsockopt=0x80,0x69,5,
listen=0x80,0x6a,2,
sigsuspend=0x80,0x6f,1,
gettimeofday=0x80,0x74,3,
getrusage=0x80,0x75,2,
getsockopt=0x80,0x76,5,
readv=0x80,0x78,3,
writev=0x80,0x79,3,
settimeofday=0x80,0x7a,2,
fchown=0x80,0x7b,3,
fchmod=0x80,0x7c,2,
setreuid=0x80,0x7e,2,
setregid=0x80,0x7f,2,
rename=0x80,0x80,2,
flock=0x80,0x83,2,
mkfifo=0x80,0x84,2,
sendto=0x80,0x85,6,
shutdown=0x80,0x86,2,
socketpair=0x80,0x87,4,
mkdir=0x80,0x88,2,
rmdir=0x80,0x89,1,
utimes=0x80,0x8a,2,
futimes=0x80,0x8b,2,
adjtime=0x80,0x8c,2,
gethostuuid=0x80,0x8e,3,
setsid=0x80,0x93,0,
getpgid=0x80,0x97,1,
setprivexec=0x80,0x98,1,
pread=0x80,0x99,4,
pwrite=0x80,0x9a,4,
nfssvc=0x80,0x9b,2,
statfs=0x80,0x9d,2,
fstatfs=0x80,0x9e,2,
unmount=0x80,0x9f,2,
getfh=0x80,0xa1,2,
quotactl=0x80,0xa5,4,
mount=0x80,0xa7,4,
csops=0x80,0xa9,4,
csops_audittoken=0x80,0xaa,5,
waitid=0x80,0xad,4,
kdebug_typefilter=0x80,0xb1,2,
kdebug_trace_string=0x80,0xb2,3,
kdebug_trace64=0x80,0xb3,5,
kdebug_trace=0x80,0xb4,5,
setgid=0x80,0xb5,1,
setegid=0x80,0xb6,1,
seteuid=0x80,0xb7,1,
sigreturn=0x80,0xb8,2,
thread_selfcounts=0x80,0xba,3,
fdatasync=0x80,0xbb,1,
stat=0x80,0xbc,2,
fstat=0x80,0xbd,2,
lstat=0x80,0xbe,2,
pathconf=0x80,0xbf,2,
fpathconf=0x80,0xc0,2,
getrlimit=0x80,0xc2,2,
setrlimit=0x80,0xc3,2,
getdirentries=0x80,0xc4,4,
mmap=0x80,0xc5,6,
lseek=0x80,0xc7,3,
truncate=0x80,0xc8,2,
ftruncate=0x80,0xc9,2,
sysctl=0x80,0xca,6,
mlock=0x80,0xcb,2,
munlock=0x80,0xcc,2,
undelete=0x80,0xcd,1,
open_dprotected_np=0x80,0xd8,5,
getattrlist=0x80,0xdc,5,
setattrlist=0x80,0xdd,5,
getdirentriesattr=0x80,0xde,8,
exchangedata=0x80,0xdf,3,
searchfs=0x80,0xe1,6,
delete=0x80,0xe2,1,
copyfile=0x80,0xe3,4,
fgetattrlist=0x80,0xe4,5,
fsetattrlist=0x80,0xe5,5,
poll=0x80,0xe6,3,
watchevent=0x80,0xe7,2,
waitevent=0x80,0xe8,2,
modwatch=0x80,0xe9,2,
getxattr=0x80,0xea,6,
fgetxattr=0x80,0xeb,6,
setxattr=0x80,0xec,6,
fsetxattr=0x80,0xed,6,
removexattr=0x80,0xee,3,
fremovexattr=0x80,0xef,3,
listxattr=0x80,0xf0,4,
flistxattr=0x80,0xf1,4,
fsctl=0x80,0xf2,4,
initgroups=0x80,0xf3,3,
posix_spawn=0x80,0xf4,5,
ffsctl=0x80,0xf5,4,
nfsclnt=0x80,0xf7,2,
fhopen=0x80,0xf8,2,
minherit=0x80,0xfa,3,
semsys=0x80,0xfb,5,
msgsys=0x80,0xfc,5,
shmsys=0x80,0xfd,4,
semctl=0x80,0xfe,4,
semget=0x80,0xff,3,
semop=0x80,0x100,3,
msgctl=0x80,0x102,3,
msgget=0x80,0x103,2,
msgsnd=0x80,0x104,4,
msgrcv=0x80,0x105,5,
shmat=0x80,0x106,3,
shmctl=0x80,0x107,3,
shmdt=0x80,0x108,1,
shmget=0x80,0x109,3,
shm_open=0x80,0x10a,3,
shm_unlink=0x80,0x10b,1,
sem_open=0x80,0x10c,4,
sem_close=0x80,0x10d,1,
sem_unlink=0x80,0x10e,1,
sem_wait=0x80,0x10f,1,
sem_trywait=0x80,0x110,1,
sem_post=0x80,0x111,1,
sysctlbyname=0x80,0x112,6,
open_extended=0x80,0x115,6,
umask_extended=0x80,0x116,2,
stat_extended=0x80,0x117,4,
lstat_extended=0x80,0x118,4,
fstat_extended=0x80,0x119,4,
chmod_extended=0x80,0x11a,5,
fchmod_extended=0x80,0x11b,5,
access_extended=0x80,0x11c,4,
settid=0x80,0x11d,2,
gettid=0x80,0x11e,2,
setsgroups=0x80,0x11f,2,
getsgroups=0x80,0x120,2,
setwgroups=0x80,0x121,2,
getwgroups=0x80,0x122,2,
mkfifo_extended=0x80,0x123,5,
mkdir_extended=0x80,0x124,5,
identitysvc=0x80,0x125,2,
shared_region_check_np=0x80,0x126,1,
vm_pressure_monitor=0x80,0x128,3,
psynch_rw_longrdlock=0x80,0x129,5,
psynch_rw_yieldwrlock=0x80,0x12a,5,
psynch_rw_downgrade=0x80,0x12b,5,
psynch_rw_upgrade=0x80,0x12c,5,
psynch_mutexwait=0x80,0x12d,5,
psynch_mutexdrop=0x80,0x12e,5,
psynch_cvbroad=0x80,0x12f,7,
psynch_cvsignal=0x80,0x130,8,
psynch_cvwait=0x80,0x131,8,
psynch_rw_rdlock=0x80,0x132,5,
psynch_rw_wrlock=0x80,0x133,5,
psynch_rw_unlock=0x80,0x134,5,
psynch_rw_unlock2=0x80,0x135,5,
getsid=0x80,0x136,1,
settid_with_pid=0x80,0x137,2,
psynch_cvclrprepost=0x80,0x138,7,
aio_fsync=0x80,0x139,2,
aio_return=0x80,0x13a,1,
aio_suspend=0x80,0x13b,3,
aio_cancel=0x80,0x13c,2,
aio_error=0x80,0x13d,1,
aio_read=0x80,0x13e,1,
aio_write=0x80,0x13f,1,
lio_listio=0x80,0x140,4,
iopolicysys=0x80,0x142,2,
process_policy=0x80,0x143,7,
mlockall=0x80,0x144,1,
munlockall=0x80,0x145,1,
issetugid=0x80,0x147,0,
__pthread_kill=0x80,0x148,2,
__pthread_sigmask=0x80,0x149,3,
__sigwait=0x80,0x14a,2,
__disable_threadsignal=0x80,0x14b,1,
__pthread_markcancel=0x80,0x14c,1,
__pthread_canceled=0x80,0x14d,1,
__semwait_signal=0x80,0x14e,6,
proc_info=0x80,0x150,6,
sendfile=0x80,0x151,6,
stat64=0x80,0x152,2,
fstat64=0x80,0x153,2,
lstat64=0x80,0x154,2,
stat64_extended=0x80,0x155,4,
lstat64_extended=0x80,0x156,4,
fstat64_extended=0x80,0x157,4,
getdirentries64=0x80,0x158,4,
statfs64=0x80,0x159,2,
fstatfs64=0x80,0x15a,2,
getfsstat64=0x80,0x15b,3,
__pthread_chdir=0x80,0x15c,1,
__pthread_fchdir=0x80,0x15d,1,
audit=0x80,0x15e,2,
auditon=0x80,0x15f,3,
getauid=0x80,0x161,1,
setauid=0x80,0x162,1,
getaudit_addr=0x80,0x165,2,
setaudit_addr=0x80,0x166,2,
auditctl=0x80,0x167,1,
bsdthread_create=0x80,0x168,5,
bsdthread_terminate=0x80,0x169,4,
kqueue=0x80,0x16a,0,
kevent=0x80,0x16b,6,
lchown=0x80,0x16c,3,
bsdthread_register=0x80,0x16e,7,
workq_open=0x80,0x16f,0,
workq_kernreturn=0x80,0x170,4,
kevent64=0x80,0x171,7,
__old_semwait_signal=0x80,0x172,5,
__old_semwait_signal_nocancel=0x80,0x173,5,
thread_selfid=0x80,0x174,0,
ledger=0x80,0x175,4,
kevent_qos=0x80,0x176,8,
kevent_id=0x80,0x177,8,
__mac_execve=0x80,0x17c,4,
__mac_syscall=0x80,0x17d,3,
__mac_get_file=0x80,0x17e,2,
__mac_set_file=0x80,0x17f,2,
__mac_get_link=0x80,0x180,2,
__mac_set_link=0x80,0x181,2,
__mac_get_proc=0x80,0x182,1,
__mac_set_proc=0x80,0x183,1,
__mac_get_fd=0x80,0x184,2,
__mac_set_fd=0x80,0x185,2,
__mac_get_pid=0x80,0x186,2,
pselect=0x80,0x18a,6,
pselect_nocancel=0x80,0x18b,6,
read_nocancel=0x80,0x18c,3,
write_nocancel=0x80,0x18d,3,
open_nocancel=0x80,0x18e,3,
close_nocancel=0x80,0x18f,1,
wait4_nocancel=0x80,0x190,4,
recvmsg_nocancel=0x80,0x191,3,
sendmsg_nocancel=0x80,0x192,3,
recvfrom_nocancel=0x80,0x193,6,
accept_nocancel=0x80,0x194,3,
msync_nocancel=0x80,0x195,3,
fcntl_nocancel=0x80,0x196,3,
select_nocancel=0x80,0x197,5,
fsync_nocancel=0x80,0x198,1,
connect_nocancel=0x80,0x199,3,
sigsuspend_nocancel=0x80,0x19a,1,
readv_nocancel=0x80,0x19b,3,
writev_nocancel=0x80,0x19c,3,
sendto_nocancel=0x80,0x19d,6,
pread_nocancel=0x80,0x19e,4,
pwrite_nocancel=0x80,0x19f,4,
waitid_nocancel=0x80,0x1a0,4,
poll_nocancel=0x80,0x1a1,3,
msgsnd_nocancel=0x80,0x1a2,4,
msgrcv_nocancel=0x80,0x1a3,5,
sem_wait_nocancel=0x80,0x1a4,1,
aio_suspend_nocancel=0x80,0x1a5,3,
__sigwait_nocancel=0x80,0x1a6,2,
__semwait_signal_nocancel=0x80,0x1a7,6,
__mac_mount=0x80,0x1a8,5,
__mac_get_mount=0x80,0x1a9,2,
__mac_getfsstat=0x80,0x1aa,5,
fsgetpath=0x80,0x1ab,4,
audit_session_self=0x80,0x1ac,0,
audit_session_join=0x80,0x1ad,1,
fileport_makeport=0x80,0x1ae,2,
fileport_makefd=0x80,0x1af,1,
audit_session_port=0x80,0x1b0,2,
pid_suspend=0x80,0x1b1,1,
pid_resume=0x80,0x1b2,1,
pid_hibernate=0x80,0x1b3,1,
pid_shutdown_sockets=0x80,0x1b4,2,
shared_region_map_and_slide_np=0x80,0x1b6,6,
kas_info=0x80,0x1b7,3,
memorystatus_control=0x80,0x1b8,5,
guarded_open_np=0x80,0x1b9,5,
guarded_close_np=0x80,0x1ba,2,
guarded_kqueue_np=0x80,0x1bb,2,
change_fdguard_np=0x80,0x1bc,6,
usrctl=0x80,0x1bd,1,
proc_rlimit_control=0x80,0x1be,3,
connectx=0x80,0x1bf,8,
disconnectx=0x80,0x1c0,3,
peeloff=0x80,0x1c1,2,
socket_delegate=0x80,0x1c2,4,
telemetry=0x80,0x1c3,6,
proc_uuid_policy=0x80,0x1c4,4,
memorystatus_get_level=0x80,0x1c5,1,
system_override=0x80,0x1c6,2,
vfs_purge=0x80,0x1c7,0,
sfi_ctl=0x80,0x1c8,4,
sfi_pidctl=0x80,0x1c9,4,
coalition=0x80,0x1ca,3,
coalition_info=0x80,0x1cb,4,
necp_match_policy=0x80,0x1cc,3,
getattrlistbulk=0x80,0x1cd,5,
clonefileat=0x80,0x1ce,5,
openat=0x80,0x1cf,4,
openat_nocancel=0x80,0x1d0,4,
renameat=0x80,0x1d1,4,
faccessat=0x80,0x1d2,4,
fchmodat=0x80,0x1d3,4,
fchownat=0x80,0x1d4,5,
fstatat=0x80,0x1d5,4,
fstatat64=0x80,0x1d6,4,
linkat=0x80,0x1d7,5,
unlinkat=0x80,0x1d8,3,
readlinkat=0x80,0x1d9,4,
symlinkat=0x80,0x1da,3,
mkdirat=0x80,0x1db,3,
getattrlistat=0x80,0x1dc,6,
proc_trace_log=0x80,0x1dd,2,
bsdthread_ctl=0x80,0x1de,4,
openbyid_np=0x80,0x1df,3,
recvmsg_x=0x80,0x1e0,4,
sendmsg_x=0x80,0x1e1,4,
thread_selfusage=0x80,0x1e2,0,
csrctl=0x80,0x1e3,3,
guarded_open_dprotected_np=0x80,0x1e4,7,
guarded_write_np=0x80,0x1e5,4,
guarded_pwrite_np=0x80,0x1e6,5,
guarded_writev_np=0x80,0x1e7,4,
renameatx_np=0x80,0x1e8,5,
mremap_encrypted=0x80,0x1e9,5,
netagent_trigger=0x80,0x1ea,2,
stack_snapshot_with_config=0x80,0x1eb,3,
microstackshot=0x80,0x1ec,3,
grab_pgo_data=0x80,0x1ed,4,
persona=0x80,0x1ee,5,
work_interval_ctl=0x80,0x1f3,4,
getentropy=0x80,0x1f4,2,
necp_open=0x80,0x1f5,1,
necp_client_action=0x80,0x1f6,6,
ulock_wait=0x80,0x203,4,
ulock_wake=0x80,0x204,3,
fclonefileat=0x80,0x205,4,
fs_snapshot=0x80,0x206,6,
terminate_with_payload=0x80,0x208,7,
abort_with_payload=0x80,0x209,6,
necp_session_open=0x80,0x20a,1,
necp_session_action=0x80,0x20b,6,
setattrlistat=0x80,0x20c,6,
net_qos_guideline=0x80,0x20d,2,
fmount=0x80,0x20e,4,
ntp_adjtime=0x80,0x20f,1,
ntp_gettime=0x80,0x210,1,
os_fault_with_payload=0x80,0x211,6,
_kernelrpc_mach_vm_allocate_trap=0x80,0xa,4,
_kernelrpc_mach_vm_purgable_control_trap=0x80,0xb,4,
_kernelrpc_mach_vm_deallocate_trap=0x80,0xc,3,
_kernelrpc_mach_vm_protect_trap=0x80,0xe,5,
_kernelrpc_mach_vm_map_trap=0x80,0xf,6,
_kernelrpc_mach_port_allocate_trap=0x80,0x10,3,
_kernelrpc_mach_port_destroy_trap=0x80,0x11,2,
_kernelrpc_mach_port_deallocate_trap=0x80,0x12,2,
_kernelrpc_mach_port_mod_refs_trap=0x80,0x13,4,
_kernelrpc_mach_port_move_member_trap=0x80,0x14,3,
_kernelrpc_mach_port_insert_right_trap=0x80,0x15,4,
_kernelrpc_mach_port_insert_member_trap=0x80,0x16,3,
_kernelrpc_mach_port_extract_member_trap=0x80,0x17,3,
_kernelrpc_mach_port_construct_trap=0x80,0x18,4,
_kernelrpc_mach_port_destruct_trap=0x80,0x19,4,
mach_reply_port=0x80,0x1a,0,
thread_self_trap=0x80,0x1b,0,
task_self_trap=0x80,0x1c,0,
host_self_trap=0x80,0x1d,0,
mach_msg_trap=0x80,0x1f,7,
mach_msg_overwrite_trap=0x80,0x20,8,
semaphore_signal_trap=0x80,0x21,1,
semaphore_signal_all_trap=0x80,0x22,1,
semaphore_signal_thread_trap=0x80,0x23,2,
semaphore_wait_trap=0x80,0x24,1,
semaphore_wait_signal_trap=0x80,0x25,2,
semaphore_timedwait_trap=0x80,0x26,3,
semaphore_timedwait_signal_trap=0x80,0x27,4,
_kernelrpc_mach_port_guard_trap=0x80,0x29,4,
_kernelrpc_mach_port_unguard_trap=0x80,0x2a,3,
mach_generate_activity_id=0x80,0x2b,3,
task_name_for_pid=0x80,0x2c,3,
task_for_pid=0x80,0x2d,3,
pid_for_task=0x80,0x2e,2,
macx_swapon=0x80,0x30,4,
macx_swapoff=0x80,0x31,2,
thread_get_special_reply_port=0x80,0x32,0,
macx_triggers=0x80,0x33,4,
macx_backing_store_suspend=0x80,0x34,1,
macx_backing_store_recovery=0x80,0x35,1,
pfz_exit=0x80,0x3a,0,
swtch_pri=0x80,0x3b,0,
swtch=0x80,0x3c,0,
thread_switch=0x80,0x3d,3,
clock_sleep_trap=0x80,0x3e,5,
host_create_mach_voucher_trap=0x80,0x46,4,
mach_voucher_extract_attr_recipe_trap=0x80,0x48,4,
mach_timebase_info_trap=0x80,0x59,1,
mach_wait_until_trap=0x80,0x5a,1,
mk_timer_create_trap=0x80,0x5b,0,
mk_timer_destroy_trap=0x80,0x5c,1,
mk_timer_arm_trap=0x80,0x5d,2,
mk_timer_cancel_trap=0x80,0x5e,2,
mk_timer_arm_leeway_trap=0x80,0x5f,4,
iokit_user_client_trap=0x80,0x64,8, rizin-0.7.4/librz/syscall/d/ios-arm-64.sdb.txt 0000664 0001750 0001750 00000021417 14731035230 020347 0 ustar sophie sophie _=0x80
exit=0x80,1,1,
fork=0x80,2,0
read=0x80,3,3,
write=0x80,4,3,
open=0x80,5,3,
close=0x80,6,1,
wait4=0x80,7,3,
link=0x80,9,2,zz
unlink=0x80,10,1,z
chdir=0x80,12,1,z
fchdir=0x80,13,1,i
mknod=0x80,14,3,zii
chmod=0x80,15,2,zi
chown=0x80,16,3,zii
getfsstat=0x80,18,3,pii
getpid=0x80,20,0,
setuid=0x80,23,1,i
getuid=0x80,24,0,
geteuid=0x80,25,0,
ptrace=0x80,26,4,
recvmsg=0x80,27,3,
sendmsg=0x80,28,3,
recvfrom=0x80,29,3,
accept=0x80,30,1,i
getpeername=0x80,31,0,
getsockname=0x80,32,0,
access=0x80,33,0,
chflags=0x80,34,0
fchflags=0x80,35,0
sync=0x80,36,0
kill=0x80,37,0
getppid=0x80,39,0
dup=0x80,41,0
pipe=0x80,42,0
getegid=0x80,43,0
sigaction=0x80,46,0
getgid=0x80,47,0
sigprocmask=0x80,48,0
getlogin=0x80,49,0
setlogin=0x80,50,0
acct=0x80,51,0
sigpending=0x80,52,0
sigaltstack=0x80,53,0
ioctl=0x80,54,0
reboot=0x80,55,0
revoke=0x80,56,0
symlink=0x80,57,0
readlink=0x80,58,0
execve=0x80,59,0
umask=0x80,60,0
chroot=0x80,61,0
msync=0x80,65,0
vfork=0x80,66,0
munmap=0x80,73,0
mprotect=0x80,74,0
madvise=0x80,75,0
mincore=0x80,78,0
getgroups=0x80,79,0
setgroups=0x80,80,0
getpgrp=0x80,81,0
setpgid=0x80,82,0
setitimer=0x80,83,0
swapon=0x80,85,0
getitimer=0x80,86,0
getdtablesize=0x80,89,0
dup2=0x80,90,0
fcntl=0x80,92,0
select=0x80,93,0
fsync=0x80,95,0
setpriority=0x80,96,0
socket=0x80,97,0
connect=0x80,98,0
getpriority=0x80,100,0
bind=0x80,104,0
setsockopt=0x80,105,0
listen=0x80,106,0
sigsuspend=0x80,111,0
gettimeofday=0x80,116,0
getrusage=0x80,117,0
getsockopt=0x80,118,0
readv=0x80,120,0
writev=0x80,121,0
settimeofday=0x80,122,0
fchown=0x80,123,0
fchmod=0x80,124,0
setreuid=0x80,126,0
setregid=0x80,127,0
rename=0x80,128,0
flock=0x80,131,0
mkfifo=0x80,132,0
sendto=0x80,133,0
shutdown=0x80,134,0
socketpair=0x80,135,0
mkdir=0x80,136,0
rmdir=0x80,137,0
utimes=0x80,138,0
futimes=0x80,139,0
adjtime=0x80,140,0
gethostuuid=0x80,142,0
setsid=0x80,147,0
getpgid=0x80,151,0
setprivexec=0x80,152,0
pread=0x80,153,0
pwrite=0x80,154,0
statfs=0x80,157,0
fstatfs=0x80,158,0
unmount=0x80,159,0
quotactl=0x80,165,0
mount=0x80,167,0
csops=0x80,169,0
170=0x80,170,0
waitid=0x80,173,0
kdebug_trace=0x80,180,0
setgid=0x80,181,0
setegid=0x80,182,0
seteuid=0x80,183,0
sigreturn=0x80,184,0
chud=0x80,185,0
fdatasync=0x80,187,0
stat=0x80,188,0
fstat=0x80,189,0
lstat=0x80,190,0
pathconf=0x80,191,0
fpathconf=0x80,192,0
getrlimit=0x80,194,0
setrlimit=0x80,195,0
getdirentries=0x80,196,0
mmap=0x80,197,0
lseek=0x80,199,0
truncate=0x80,200,0
ftruncate=0x80,201,0
__sysctl=0x80,202,0
mlock=0x80,203,0
munlock=0x80,204,0
undelete=0x80,205,0
mkcomplex=0x80,216,0
getattrlist=0x80,220,0
setattrlist=0x80,221,0
getdirentriesattr=0x80,222,0
exchangedata=0x80,223,0
searchfs=0x80,225,0
delete=0x80,226,0
copyfile=0x80,227,0
fgetattrlist=0x80,228,0
fsetattrlist=0x80,229,0
poll=0x80,230,0
watchevent=0x80,231,0
waitevent=0x80,232,0
modwatch=0x80,233,0
getxattr=0x80,234,0
fgetxattr=0x80,235,0
setxattr=0x80,236,0
fsetxattr=0x80,237,0
removexattr=0x80,238,0
fremovexattr=0x80,239,0
listxattr=0x80,240,0
flistxattr=0x80,241,0
fsctl=0x80,242,0
initgroups=0x80,243,0
posix_spawn=0x80,244,0
ffsctl=0x80,245,0
minherit=0x80,250,0
shm_open=0x80,266,0
shm_unlink=0x80,267,0
sem_open=0x80,268,0
sem_close=0x80,269,0
sem_unlink=0x80,270,0
sem_wait=0x80,271,0
sem_trywait=0x80,272,0
sem_post=0x80,273,0
sem_getvalue=0x80,274,0
sem_init=0x80,275,0
sem_destroy=0x80,276,0
open_extended=0x80,277,0
umask_extended=0x80,278,0
stat_extended=0x80,279,0
lstat_extended=0x80,280,0
fstat_extended=0x80,281,0
chmod_extended=0x80,282,0
fchmod_extended=0x80,283,0
access_extended=0x80,284,0
settid=0x80,285,0
gettid=0x80,286,0
setsgroups=0x80,287,0
getsgroups=0x80,288,0
setwgroups=0x80,289,0
getwgroups=0x80,290,0
mkfifo_extended=0x80,291,0
mkdir_extended=0x80,292,0
shared_region_check_np=0x80,294,0
vm_pressure_monitor=0x80,296,0
psynch_rw_longrdlock=0x80,297,0
psynch_rw_yieldwrlock=0x80,298,0
psynch_rw_downgrade=0x80,299,0
psynch_rw_upgrade=0x80,300,0
psynch_mutexwait=0x80,301,0
psynch_mutexdrop=0x80,302,0
psynch_cvbroad=0x80,303,0
psynch_cvsignal=0x80,304,0
psynch_cvwait=0x80,305,0
psynch_rw_rdlock=0x80,306,0
psynch_rw_wrlock=0x80,307,0
psynch_rw_unlock=0x80,308,0
psynch_rw_unlock2=0x80,309,0
getsid=0x80,310,0
settid_with_pid=0x80,311,0
psynch_cvclrprepost=0x80,312,0
aio_fsync=0x80,313,0
aio_return=0x80,314,0
aio_suspend=0x80,315,0
aio_cancel=0x80,316,0
aio_error=0x80,317,0
aio_read=0x80,318,0
aio_write=0x80,319,0
lio_listio=0x80,320,0
iopolicysys=0x80,322,0
process_policy=0x80,323,0
mlockall=0x80,324,0
munlockall=0x80,325,0
issetugid=0x80,327,0
__pthread_kill=0x80,328,0
__pthread_sigmask=0x80,329,0
__sigwait=0x80,330,0
__disable_threadsignal=0x80,331,0
__pthread_markcancel=0x80,332,0
__pthread_canceled=0x80,333,0
__semwait_signal=0x80,334,0
proc_info=0x80,336,0
stat64=0x80,338,0
fstat64=0x80,339,0
lstat64=0x80,340,0
stat64_extended=0x80,341,0
lstat64_extended=0x80,342,0
fstat64_extended=0x80,343,0
getdirentries64=0x80,344,0
statfs64=0x80,345,0
fstatfs64=0x80,346,0
getfsstat64=0x80,347,0
__pthread_chdir=0x80,348,0
__pthread_fchdir=0x80,349,0
audit=0x80,350,0
auditon=0x80,351,0
getauid=0x80,353,0
setauid=0x80,354,0
getaudit_addr=0x80,357,0
setaudit_addr=0x80,358,0
auditctl=0x80,359,0
bsdthread_create=0x80,360,0
bsdthread_terminate=0x80,361,0
kqueue=0x80,362,0
kevent=0x80,363,0
lchown=0x80,364,0
stack_snapshot=0x80,365,0
bsdthread_register=0x80,366,0
workq_open=0x80,367,0
workq_kernreturn=0x80,368,0
kevent64=0x80,369,7,
__old_semwait_signal=0x80,370,0
__old_semwait_signal_nocancel=0x80,371,0
thread_selfid=0x80,372,0
ledger=0x80,373,0
__mac_execve=0x80,380,0
__mac_syscall=0x80,381,0
__mac_get_file=0x80,382,0
__mac_set_file=0x80,383,0
__mac_get_link=0x80,384,0
__mac_set_link=0x80,385,0
__mac_get_proc=0x80,386,0
__mac_set_proc=0x80,387,0
__mac_get_fd=0x80,388,0
__mac_set_fd=0x80,389,0
__mac_get_pid=0x80,390,0
__mac_get_lcid=0x80,391,0
__mac_get_lctx=0x80,392,0
__mac_set_lctx=0x80,393,0
setlcid=0x80,394,0
getlcid=0x80,395,0
read_nocancel=0x80,396,0
write_nocancel=0x80,397,0
open_nocancel=0x80,398,0
close_nocancel=0x80,399,0
wait4_nocancel=0x80,400,0
recvmsg_nocancel=0x80,401,0
sendmsg_nocancel=0x80,402,0
recvfrom_nocancel=0x80,403,0
accept_nocancel=0x80,404,0
msync_nocancel=0x80,405,0
fcntl_nocancel=0x80,406,0
select_nocancel=0x80,407,0
fsync_nocancel=0x80,408,0
connect_nocancel=0x80,409,0
sigsuspend_nocancel=0x80,410,0
readv_nocancel=0x80,411,0
writev_nocancel=0x80,412,0
sendto_nocancel=0x80,413,0
pread_nocancel=0x80,414,0
pwrite_nocancel=0x80,415,0
waitid_nocancel=0x80,416,0
poll_nocancel=0x80,417,0
sem_wait_nocancel=0x80,420,0
aio_suspend_nocancel=0x80,421,0
__sigwait_nocancel=0x80,422,0
__semwait_signal_nocancel=0x80,423,0
__mac_mount=0x80,424,0
__mac_get_mount=0x80,425,0
__mac_getfsstat=0x80,426,0
fsgetpath=0x80,427,0
audit_session_self=0x80,428,0
audit_session_join=0x80,429,0
fileport_makeport=0x80,430,0
fileport_makefd=0x80,431,0
audit_session_port=0x80,432,0
pid_suspend=0x80,433,0
pid_resume=0x80,434,0
pid_hibernate=0x80,435,0
pid_shutdown_sockets=0x80,436,0
shared_region_map_and_slide_np=0x80,438,0
kas_info=0x80,439,0
memorystatus_control=0x80,440,0
guarded_open_np=0x80,441,0
guarded_close_np=0x80,442,0
guarded_kqueue_np=0x80,443,0
change_fdguard_np=0x80,444,0
old __proc_suppress=0x80,445,0
proc_rlimit_control=0x80,446,0
proc_connectx=0x80,447,0
proc_disconnectx=0x80,448,0
proc_peeloff=0x80,449,0
proc_socket_delegate=0x80,450,0
proc_telemetry=0x80,451,0
proc_uuid_policy=0x80,452,0
memorystatus_get_level=0x80,453,0
system_override=0x80,454,0
vfs_purge=0x80,455,0
sfi_ctl=0x80,456,0
sfi_pidctl=0x80,457,0
coalition=0x80,458,0
coalition_info=0x80,459,0
necp_match_policy=0x80,460,0
getattrlistbulk=0x80,461,0
placeholder for clonefile=0x80,462,0
openat=0x80,463,0
openat_nocancel=0x80,464,0
renameat=0x80,465,0
faccessat=0x80,466,0
fchmodat=0x80,467,0
fchownat=0x80,468,0
fstatat=0x80,469,0
fstatat64=0x80,470,0
linkat=0x80,471,0
unlinkat=0x80,472,0
readlinkat=0x80,473,0
symlinkat=0x80,474,0
mkdirat=0x80,475,0
getattrlistat=0x80,476,0
proc_trace_log=0x80,477,0
bsdthread_ctl=0x80,478,0
openbyid_np=0x80,479,0
recvmsg_x=0x80,480,0
sendmsg_x=0x80,481,0
thread_selfusage=0x80,482,0
guarded_open_dprotected_np=0x80,484,0
guarded_write_np=0x80,485,0
guarded_pwrite_np=0x80,486,0
guarded_writev_np=0x80,487,0
rename_ext=0x80,488,0
mremap_encrypted=0x80,489,0
netagent_trigger=0x80,490,0
stack_snapshot_with_config=0x80,491,0
microstackshot=0x80,492,0
grab_pgo_data=0x80,493,0
persona=0x80,494,0
work_interval_ctl=0x80,499,0
getentropy=0x80,500,0
necp_open=0x80,501,0
necp_client_action=0x80,502,0
__nexus_open=0x80,503,0
__nexus_register=0x80,504,0
__nexus_deregister=0x80,505,0
__nexus_create=0x80,506,0
__nexus_destroy=0x80,507,0
__nexus_get_opt=0x80,508,0
__nexus_set_opt=0x80,509,0
__channel_open=0x80,510,0
__channel_get_info=0x80,511,0
__channel_sync=0x80,512,0
__channel_get_opt=0x80,513,0
__channel_set_opt=0x80,514,0
ulock_wait=0x80,515,0
ulock_wake=0x80,516,0
fclonefileat=0x80,517,0
fs_snapshot=0x80,518,0
terminate_with_payload=0x80,520,0
rizin-0.7.4/librz/syscall/d/linux-x86-32.sdb.txt 0000664 0001750 0001750 00000022235 14731035230 020554 0 ustar sophie sophie _=0x80
exit=0x80,1,1,i
fork=0x80,2,0,
read=0x80,3,3,ipi
write=0x80,4,3,iZi
open=0x80,5,3,zxx
close=0x80,6,1,i
waitpid=0x80,7,3,ipx
creat=0x80,8,2,zx
link=0x80,9,2,zz
unlink=0x80,10,1,z
execve=0x80,11,3,zpp
chdir=0x80,12,1,z
time=0x80,13,1,
mknod=0x80,14,3,
chmod=0x80,15,2,
lchown=0x80,16,3,
stat=0x80,18,2,
lseek=0x80,19,3,
getpid=0x80,20,0,
mount=0x80,21,3,
oldumount=0x80,22,1,
setuid=0x80,23,1,i
getuid=0x80,24,0,
stime=0x80,25,1,
ptrace=0x80,26,4,
alarm=0x80,27,1,
fstat=0x80,28,2,
pause=0x80,29,0,
utime=0x80,30,2,
access=0x80,33,2,
nice=0x80,34,1,
sync=0x80,36,0,
kill=0x80,37,2,
rename=0x80,38,2,
mkdir=0x80,39,2,zi
rmdir=0x80,40,1,zi
dup=0x80,41,2,
pipe=0x80,42,1,
times=0x80,43,1,
brk=0x80,45,1,
setgid=0x80,46,1,
getgid=0x80,47,0,
signal=0x80,48,2,
geteuid=0x80,49,0,
getegid=0x80,50,0,
acct=0x80,51,1,
umount=0x80,52,2,
ioctl=0x80,54,3,
fcntl=0x80,55,3,
setpgid=0x80,57,2,
olduname=0x80,59,1,
umask=0x80,60,1,
chroot=0x80,61,1,
ustat=0x80,62,2,
dup2=0x80,63,2,
getppid=0x80,64,0,
getpgrp=0x80,65,0,
setsid=0x80,66,0,
sigaction=0x80,67,3,
sgetmask=0x80,68,0,
ssetmask=0x80,69,1,
setreuid=0x80,70,2,
setregid=0x80,71,2,
sigsuspend=0x80,72,3,
sigpending=0x80,73,1,
sethostname=0x80,74,2,
setrlimit=0x80,75,2,
getrlimit=0x80,76,2,
getrusage=0x80,77,2,
gettimeofday=0x80,78,2,
settimeofday=0x80,79,2,
getgroups=0x80,80,2,
setgroups=0x80,81,2,
old_select=0x80,82,1,
symlink=0x80,83,2,
lstat=0x80,84,2,
readlink=0x80,85,3,
uselib=0x80,86,1,
swapon=0x80,87,2,
reboot=0x80,88,4,
old_readdir=0x80,89,3,
mmap=0x80,90,6,
munmap=0x80,91,1,
truncate=0x80,92,2,
ftruncate=0x80,93,2,
fchmod=0x80,94,2,
fchown=0x80,95,3,
getpriority=0x80,96,2,
setpriority=0x80,97,3,
statfs=0x80,99,2,
fstatfs=0x80,100,2,
ioperm=0x80,101,3,
socketcall=0x80,102,2,
syslog=0x80,103,3,
setitimer=0x80,104,3,
getitimer=0x80,105,2,
newstat=0x80,106,2,
newlstat=0x80,107,2,
newfstat=0x80,108,2,
uname=0x80,109,1,
iopl=0x80,110,1,
vhangup=0x80,111,0,
idle=0x80,112,0,
vm86old=0x80,113,2,
wait4=0x80,114,4,
swapoff=0x80,115,1,
sysinfo=0x80,116,1,
ipc=0x80,117,5,
fsync=0x80,118,1,
sigreturn=0x80,119,1,
clone=0x80,120,4,
setdomainname=0x80,121,2,
newuname=0x80,122,1,
modify_ldt=0x80,123,3,
adjtimex=0x80,124,1,
mprotect=0x80,125,3,
sigprocmask=0x80,126,3,
create_module=0x80,127,2,
init_module=0x80,128,2,
delete_module=0x80,129,1,
get_kernel_syms=0x80,130,1,
quotactl=0x80,131,4,
getpgid=0x80,132,1,
fchdir=0x80,133,1,
bdflush=0x80,134,2,
sysfs=0x80,135,3,
personality=0x80,136,1,
setfsuid=0x80,138,1,
setfsgid=0x80,139,1,
llseek=0x80,140,5,
getdents=0x80,141,3,
select=0x80,142,5,
flock=0x80,143,2,
msync=0x80,144,3,
readv=0x80,145,3,
writev=0x80,146,3,
getsid=0x80,147,1,
fdatasync=0x80,148,1,
sysctl=0x80,149,1,
mlock=0x80,150,2,
munlock=0x80,151,2,
mlockall=0x80,152,1,
munlockall=0x80,153,0,
sched_setparam=0x80,154,2,
sched_getparam=0x80,155,2,
sched_setscheduler=0x80,156,3,
sched_getscheduler=0x80,157,1,
sched_yield=0x80,158,0,
sched_get_priority_max=0x80,159,1,
sched_get_priority_min=0x80,160,1,
sched_rr_get_interval=0x80,161,2,
nanosleep=0x80,162,2,
mremap=0x80,163,4,
setresuid=0x80,164,3,
getresuid=0x80,165,3,
vm86=0x80,166,1,
query_module=0x80,167,5,
poll=0x80,168,3,
nfsservctl=0x80,169,3,
setresgid=0x80,170,3,
getresgid=0x80,171,3,
prctl=0x80,172,5,
rt_sigreturn=0x80,173,1,
rt_sigaction=0x80,174,3,
rt_sigprocmask=0x80,175,3,
rt_sigpending=0x80,176,2,
rt_sigtimedwait=0x80,177,4,
rt_sigqueueinfo=0x80,178,3,
rt_sigsuspend=0x80,179,2,
pread=0x80,180,4,
pwrite=0x80,181,4,
chown=0x80,182,3,
getcwd=0x80,183,2,
capget=0x80,184,2,
capset=0x80,185,2,
sigaltstack=0x80,186,2,
sendfile=0x80,187,4,
vfork=0x80,190,0,
mmap2=0x80,192,6,
fstat64=0x80,197,2,
lchown32=0x80,198,3,
getuid32=0x80,199,0,
getgid32=0x80,200,0,
geteuid32=0x80,201,0,
getegid32=0x80,202,0,
setreuid32=0x80,203,2,
setregid32=0x80,204,2,
getgroups32=0x80,205,2,
setgroups32=0x80,206,2,
fchown32=0x80,207,3,
setresuid32=0x80,208,3,
getresuid32=0x80,209,3,
setresgid32=0x80,210,3,
getresgid32=0x80,211,3,
chown32=0x80,212,3,
setuid32=0x80,213,1,
setgid32=0x80,214,1,
setfsuid32=0x80,215,1,
setfsgid32=0x80,216,1,
pivot_root=0x80,217,2,
mincore=0x80,218,3,
madvise=0x80,219,3,
getdents64=0x80,220,3,
fcntl64=0x80,221,3,
gettid=0x80,224,0,
readahead=0x80,225,4,
setxattr=0x80,226,5,
lsetxattr=0x80,227,5,
fsetxattr=0x80,228,5,
getxattr=0x80,229,4,
lgetxattr=0x80,230,4,
fgetxattr=0x80,231,4,
listxattr=0x80,232,3,
llistxattr=0x80,233,3,
flistxattr=0x80,234,3,
removexattr=0x80,235,2,
lremovexattr=0x80,236,2,
fremovexattr=0x80,237,2,
tkill=0x80,238,2,
sendfile64=0x80,239,4,
futex=0x80,240,6,
sched_setaffinity=0x80,241,3,
sched_getaffinity=0x80,242,3,
set_thread_area=0x80,243,1,
get_thread_area=0x80,244,1,
io_setup=0x80,245,2,
io_destroy=0x80,246,1,
io_getevents=0x80,247,5,
io_submit=0x80,248,3,
io_cancel=0x80,249,3,
fadvise64=0x80,250,5,
exit_group=0x80,252,1,
lookup_dcookie=0x80,253,4,
epoll_create=0x80,254,1,
epoll_ctl=0x80,255,4,
epoll_wait=0x80,256,4,
remap_file_pages=0x80,257,5,
set_tid_address=0x80,258,1,
timer_create=0x80,259,3,
timer_settime=0x80,260,4,
timer_gettime=0x80,261,2,
timer_getoverrun=0x80,262,1,
timer_delete=0x80,263,1,
clock_settime=0x80,264,2,
clock_gettime=0x80,265,2,
clock_getres=0x80,266,2,
clock_nanosleep=0x80,267,4,
statfs64=0x80,268,3,
fstatfs64=0x80,269,3,
tgkill=0x80,270,3,
utimes=0x80,271,2,
fadvise64_64=0x80,272,6,
vserver=0x80,273,5,
mbind=0x80,274,6,
get_mempolicy=0x80,275,5,
set_mempolicy=0x80,276,3,
mq_open=0x80,277,4,
mq_unlink=0x80,278,1,
mq_timedsend=0x80,279,5,
mq_timedreceive=0x80,280,5,
mq_notify=0x80,281,2,
mq_getsetattr=0x80,282,3,
kexec_load=0x80,283,4,
waitid=0x80,284,5,
add_key=0x80,286,5,
request_key=0x80,287,4,
keyctl=0x80,288,5,
ioprio_set=0x80,289,3,
ioprio_get=0x80,290,2,
inotify_init=0x80,291,0,
inotify_add_watch=0x80,292,3,
inotify_rm_watch=0x80,293,2,
migrate_pages=0x80,294,4,
openat=0x80,295,4,
mkdirat=0x80,296,3,
mknodat=0x80,297,4,
fchownat=0x80,298,5,
futimesat=0x80,299,3,
fstatat64=0x80,300,4,
unlinkat=0x80,301,3,
renameat=0x80,302,4,
linkat=0x80,303,5,
symlinkat=0x80,304,3,
readlinkat=0x80,305,4,
fchmodat=0x80,306,3,
faccessat=0x80,307,3,
pselect6=0x80,308,6,
ppoll=0x80,309,5,
unshare=0x80,310,1,
set_robust_list=0x80,311,2,
get_robust_list=0x80,312,3,
splice=0x80,313,6,
sync_file_range=0x80,314,6,
tee=0x80,315,4,
vmsplice=0x80,316,4,
move_pages=0x80,317,6,
getcpu=0x80,318,3,
epoll_pwait=0x80,319,6,
utimensat=0x80,320,4,
signalfd=0x80,321,3,
timerfd_create=0x80,322,2,
eventfd=0x80,323,1,
fallocate=0x80,324,6,
timerfd_settime=0x80,325,4,
timerfd_gettime=0x80,326,2,
signalfd4=0x80,327,4,
eventfd2=0x80,328,2,
epoll_create1=0x80,329,1,
dup3=0x80,330,3,
pipe2=0x80,331,2,
inotify_init1=0x80,332,1,
preadv=0x80,333,5,
pwritev=0x80,334,5,
rt_tgsigqueueinfo=0x80,335,4,
perf_event_open=0x80,336,5,
recvmmsg=0x80,337,5,
fanotify_init=0x80,338,2,
fanotify_mark=0x80,339,6,
prlimit64=0x80,340,4,
name_to_handle_at=0x80,341,5,
open_by_handle_at=0x80,342,3,
clock_adjtime=0x80,343,2,
syncfs=0x80,344,1,
sendmmsg=0x80,345,4,
setns=0x80,346,2,
process_vm_readv=0x80,347,6,
process_vm_writev=0x80,348,6,
kcmp=0x80,349,5,
finit_module=0x80,350,3,
sched_setattr=0x80,351,3,
sched_getattr=0x80,352,4,
renameat2=0x80,353,5,
seccomp=0x80,354,3,
getrandom=0x80,355,3,pii,
memfd_create=0x80,356,2,
bpf=0x80,357,3,
execveat=0x80,358,5,
socket=0x80,359,3,
socketpair=0x80,360,4,
bind=0x80,361,3,
connect=0x80,362,3,
listen=0x80,363,2,
accept4=0x80,364,4,
getsockopt=0x80,365,5,
setsockopt=0x80,366,5,
getsockname=0x80,367,3,
getpeername=0x80,368,3,
sendto=0x80,369,6,
sendmsg=0x80,370,3,
recvfrom=0x80,371,6,
recvmsg=0x80,372,3,
shutdown=0x80,373,2,
userfaultfd=0x80,374,1,
membarrier=0x80,375,2,
mlock2=0x80,376,3,
copy_file_range=0x80,377,6,
preadv2=0x80,378,6,
pwritev2=0x80,379,6,
pkey_mprotect=0x80,380,4,
pkey_alloc=0x80,381,2,
pkey_free=0x80,382,1,
statx=0x80,383,5,
arch_prctl=0x80,384,2,
io_pgetevents=0x80,385,6,
rseq=0x80,386,4,
semget=0x80,393,3,
semctl=0x80,394,4,
shmget=0x80,395,3,
shmctl=0x80,396,3,
shmat=0x80,397,3,
shmdt=0x80,398,1,
msgget=0x80,399,2,
msgsnd=0x80,400,4,
msgrcv=0x80,401,5,
msgctl=0x80,402,3,
clock_gettime64=0x80,403,2,
clock_settime64=0x80,404,2,
clock_adjtime64=0x80,405,2,
clock_getres_time64=0x80,406,2,
clock_nanosleep_time64=0x80,407,4,
timer_gettime64=0x80,408,2,
timer_settime64=0x80,409,4,
timerfd_gettime64=0x80,410,2,
timerfd_settime64=0x80,411,4,
utimensat_time64=0x80,412,4,
pselect6_time64=0x80,413,6,
ppoll_time64=0x80,414,5,
io_pgetevents_time64=0x80,416,6,
recvmmsg_time64=0x80,417,5,
mq_timedsend_time64=0x80,418,5,
mq_timedreceive_time64=0x80,419,5,
semtimedop_time64=0x80,420,4,
rt_sigtimedwait_time64=0x80,421,4,
futex_time64=0x80,422,6,
sched_rr_get_interval_time64=0x80,423,2,
pidfd_send_signal=0x80,424,4,
io_uring_setup=0x80,425,2,
io_uring_enter=0x80,426,5,
io_uring_register=0x80,427,4,
open_tree=0x80,428,3,
move_mount=0x80,429,5,
fsopen=0x80,430,2,
fsconfig=0x80,431,5,
fsmount=0x80,432,3,
fspick=0x80,433,3,
pidfd_open=0x80,434,2,
clone3=0x80,435,2,
close_range=0x80,436,3,
openat2=0x80,437,4,
pidfd_getfd=0x80,438,3,
faccessat2=0x80,439,4,
process_madvise=0x80,440,5,
epoll_pwait2=0x80,441,6,
mount_setattr=0x80,442,5,
quotactl_fd=0x80,443,4,
landlock_create_ruleset=0x80,444,3,
landlock_add_rule=0x80,445,4,
landlock_restrict_self=0x80,446,2,
memfd_secret=0x80,447,1,
process_mrelease=0x80,448,2,
futex_waitv=0x80,449,5,
set_mempolicy_home_node=0x80,450,4,
cachestat=0x80,451,4,
rizin-0.7.4/librz/syscall/d/par.sh 0000775 0001750 0001750 00000000142 14731035230 016352 0 ustar sophie sophie #!/bin/sh
grep '{ "'|tr '{",}' ' ' |sed -e 's,NULL,,g' | awk '{ print $1"="$2","$3","$4","$5}'
rizin-0.7.4/librz/syscall/d/darwin-arm-32.sdb.txt 0000664 0001750 0001750 00000021417 14731035230 021034 0 ustar sophie sophie _=0x81
exit=0x81,1,1,
fork=0x81,2,0
read=0x81,3,3,
write=0x81,4,3,
open=0x81,5,3,
close=0x81,6,1,
wait4=0x81,7,3,
link=0x81,9,2,zz
unlink=0x81,10,1,z
chdir=0x81,12,1,z
fchdir=0x81,13,1,i
mknod=0x81,14,3,zii
chmod=0x81,15,2,zi
chown=0x81,16,3,zii
getfsstat=0x81,18,3,pii
getpid=0x81,20,0,
setuid=0x81,23,1,i
getuid=0x81,24,0,
geteuid=0x81,25,0,
ptrace=0x81,26,4,
recvmsg=0x81,27,3,
sendmsg=0x81,28,3,
recvfrom=0x81,29,3,
accept=0x81,30,1,i
getpeername=0x81,31,0,
getsockname=0x81,32,0,
access=0x81,33,0,
chflags=0x81,34,0
fchflags=0x81,35,0
sync=0x81,36,0
kill=0x81,37,0
getppid=0x81,39,0
dup=0x81,41,0
pipe=0x81,42,0
getegid=0x81,43,0
sigaction=0x81,46,0
getgid=0x81,47,0
sigprocmask=0x81,48,0
getlogin=0x81,49,0
setlogin=0x81,50,0
acct=0x81,51,0
sigpending=0x81,52,0
sigaltstack=0x81,53,0
ioctl=0x81,54,0
reboot=0x81,55,0
revoke=0x81,56,0
symlink=0x81,57,0
readlink=0x81,58,0
execve=0x81,59,0
umask=0x81,60,0
chroot=0x81,61,0
msync=0x81,65,0
vfork=0x81,66,0
munmap=0x81,73,0
mprotect=0x81,74,0
madvise=0x81,75,0
mincore=0x81,78,0
getgroups=0x81,79,0
setgroups=0x81,80,0
getpgrp=0x81,81,0
setpgid=0x81,82,0
setitimer=0x81,83,0
swapon=0x81,85,0
getitimer=0x81,86,0
getdtablesize=0x81,89,0
dup2=0x81,90,0
fcntl=0x81,92,0
select=0x81,93,0
fsync=0x81,95,0
setpriority=0x81,96,0
socket=0x81,97,0
connect=0x81,98,0
getpriority=0x81,100,0
bind=0x81,104,0
setsockopt=0x81,105,0
listen=0x81,106,0
sigsuspend=0x81,111,0
gettimeofday=0x81,116,0
getrusage=0x81,117,0
getsockopt=0x81,118,0
readv=0x81,120,0
writev=0x81,121,0
settimeofday=0x81,122,0
fchown=0x81,123,0
fchmod=0x81,124,0
setreuid=0x81,126,0
setregid=0x81,127,0
rename=0x81,128,0
flock=0x81,131,0
mkfifo=0x81,132,0
sendto=0x81,133,0
shutdown=0x81,134,0
socketpair=0x81,135,0
mkdir=0x81,136,0
rmdir=0x81,137,0
utimes=0x81,138,0
futimes=0x81,139,0
adjtime=0x81,140,0
gethostuuid=0x81,142,0
setsid=0x81,147,0
getpgid=0x81,151,0
setprivexec=0x81,152,0
pread=0x81,153,0
pwrite=0x81,154,0
statfs=0x81,157,0
fstatfs=0x81,158,0
unmount=0x81,159,0
quotactl=0x81,165,0
mount=0x81,167,0
csops=0x81,169,0
170=0x81,170,0
waitid=0x81,173,0
kdebug_trace=0x81,180,0
setgid=0x81,181,0
setegid=0x81,182,0
seteuid=0x81,183,0
sigreturn=0x81,184,0
chud=0x81,185,0
fdatasync=0x81,187,0
stat=0x81,188,0
fstat=0x81,189,0
lstat=0x81,190,0
pathconf=0x81,191,0
fpathconf=0x81,192,0
getrlimit=0x81,194,0
setrlimit=0x81,195,0
getdirentries=0x81,196,0
mmap=0x81,197,0
lseek=0x81,199,0
truncate=0x81,200,0
ftruncate=0x81,201,0
__sysctl=0x81,202,0
mlock=0x81,203,0
munlock=0x81,204,0
undelete=0x81,205,0
mkcomplex=0x81,216,0
getattrlist=0x81,220,0
setattrlist=0x81,221,0
getdirentriesattr=0x81,222,0
exchangedata=0x81,223,0
searchfs=0x81,225,0
delete=0x81,226,0
copyfile=0x81,227,0
fgetattrlist=0x81,228,0
fsetattrlist=0x81,229,0
poll=0x81,230,0
watchevent=0x81,231,0
waitevent=0x81,232,0
modwatch=0x81,233,0
getxattr=0x81,234,0
fgetxattr=0x81,235,0
setxattr=0x81,236,0
fsetxattr=0x81,237,0
removexattr=0x81,238,0
fremovexattr=0x81,239,0
listxattr=0x81,240,0
flistxattr=0x81,241,0
fsctl=0x81,242,0
initgroups=0x81,243,0
posix_spawn=0x81,244,0
ffsctl=0x81,245,0
minherit=0x81,250,0
shm_open=0x81,266,0
shm_unlink=0x81,267,0
sem_open=0x81,268,0
sem_close=0x81,269,0
sem_unlink=0x81,270,0
sem_wait=0x81,271,0
sem_trywait=0x81,272,0
sem_post=0x81,273,0
sem_getvalue=0x81,274,0
sem_init=0x81,275,0
sem_destroy=0x81,276,0
open_extended=0x81,277,0
umask_extended=0x81,278,0
stat_extended=0x81,279,0
lstat_extended=0x81,280,0
fstat_extended=0x81,281,0
chmod_extended=0x81,282,0
fchmod_extended=0x81,283,0
access_extended=0x81,284,0
settid=0x81,285,0
gettid=0x81,286,0
setsgroups=0x81,287,0
getsgroups=0x81,288,0
setwgroups=0x81,289,0
getwgroups=0x81,290,0
mkfifo_extended=0x81,291,0
mkdir_extended=0x81,292,0
shared_region_check_np=0x81,294,0
vm_pressure_monitor=0x81,296,0
psynch_rw_longrdlock=0x81,297,0
psynch_rw_yieldwrlock=0x81,298,0
psynch_rw_downgrade=0x81,299,0
psynch_rw_upgrade=0x81,300,0
psynch_mutexwait=0x81,301,0
psynch_mutexdrop=0x81,302,0
psynch_cvbroad=0x81,303,0
psynch_cvsignal=0x81,304,0
psynch_cvwait=0x81,305,0
psynch_rw_rdlock=0x81,306,0
psynch_rw_wrlock=0x81,307,0
psynch_rw_unlock=0x81,308,0
psynch_rw_unlock2=0x81,309,0
getsid=0x81,310,0
settid_with_pid=0x81,311,0
psynch_cvclrprepost=0x81,312,0
aio_fsync=0x81,313,0
aio_return=0x81,314,0
aio_suspend=0x81,315,0
aio_cancel=0x81,316,0
aio_error=0x81,317,0
aio_read=0x81,318,0
aio_write=0x81,319,0
lio_listio=0x81,320,0
iopolicysys=0x81,322,0
process_policy=0x81,323,0
mlockall=0x81,324,0
munlockall=0x81,325,0
issetugid=0x81,327,0
__pthread_kill=0x81,328,0
__pthread_sigmask=0x81,329,0
__sigwait=0x81,330,0
__disable_threadsignal=0x81,331,0
__pthread_markcancel=0x81,332,0
__pthread_canceled=0x81,333,0
__semwait_signal=0x81,334,0
proc_info=0x81,336,0
stat64=0x81,338,0
fstat64=0x81,339,0
lstat64=0x81,340,0
stat64_extended=0x81,341,0
lstat64_extended=0x81,342,0
fstat64_extended=0x81,343,0
getdirentries64=0x81,344,0
statfs64=0x81,345,0
fstatfs64=0x81,346,0
getfsstat64=0x81,347,0
__pthread_chdir=0x81,348,0
__pthread_fchdir=0x81,349,0
audit=0x81,350,0
auditon=0x81,351,0
getauid=0x81,353,0
setauid=0x81,354,0
getaudit_addr=0x81,357,0
setaudit_addr=0x81,358,0
auditctl=0x81,359,0
bsdthread_create=0x81,360,0
bsdthread_terminate=0x81,361,0
kqueue=0x81,362,0
kevent=0x81,363,0
lchown=0x81,364,0
stack_snapshot=0x81,365,0
bsdthread_register=0x81,366,0
workq_open=0x81,367,0
workq_kernreturn=0x81,368,0
kevent64=0x81,369,7,
__old_semwait_signal=0x81,370,0
__old_semwait_signal_nocancel=0x81,371,0
thread_selfid=0x81,372,0
ledger=0x81,373,0
__mac_execve=0x81,380,0
__mac_syscall=0x81,381,0
__mac_get_file=0x81,382,0
__mac_set_file=0x81,383,0
__mac_get_link=0x81,384,0
__mac_set_link=0x81,385,0
__mac_get_proc=0x81,386,0
__mac_set_proc=0x81,387,0
__mac_get_fd=0x81,388,0
__mac_set_fd=0x81,389,0
__mac_get_pid=0x81,390,0
__mac_get_lcid=0x81,391,0
__mac_get_lctx=0x81,392,0
__mac_set_lctx=0x81,393,0
setlcid=0x81,394,0
getlcid=0x81,395,0
read_nocancel=0x81,396,0
write_nocancel=0x81,397,0
open_nocancel=0x81,398,0
close_nocancel=0x81,399,0
wait4_nocancel=0x81,400,0
recvmsg_nocancel=0x81,401,0
sendmsg_nocancel=0x81,402,0
recvfrom_nocancel=0x81,403,0
accept_nocancel=0x81,404,0
msync_nocancel=0x81,405,0
fcntl_nocancel=0x81,406,0
select_nocancel=0x81,407,0
fsync_nocancel=0x81,408,0
connect_nocancel=0x81,409,0
sigsuspend_nocancel=0x81,410,0
readv_nocancel=0x81,411,0
writev_nocancel=0x81,412,0
sendto_nocancel=0x81,413,0
pread_nocancel=0x81,414,0
pwrite_nocancel=0x81,415,0
waitid_nocancel=0x81,416,0
poll_nocancel=0x81,417,0
sem_wait_nocancel=0x81,420,0
aio_suspend_nocancel=0x81,421,0
__sigwait_nocancel=0x81,422,0
__semwait_signal_nocancel=0x81,423,0
__mac_mount=0x81,424,0
__mac_get_mount=0x81,425,0
__mac_getfsstat=0x81,426,0
fsgetpath=0x81,427,0
audit_session_self=0x81,428,0
audit_session_join=0x81,429,0
fileport_makeport=0x81,430,0
fileport_makefd=0x81,431,0
audit_session_port=0x81,432,0
pid_suspend=0x81,433,0
pid_resume=0x81,434,0
pid_hibernate=0x81,435,0
pid_shutdown_sockets=0x81,436,0
shared_region_map_and_slide_np=0x81,438,0
kas_info=0x81,439,0
memorystatus_control=0x81,440,0
guarded_open_np=0x81,441,0
guarded_close_np=0x81,442,0
guarded_kqueue_np=0x81,443,0
change_fdguard_np=0x81,444,0
old __proc_suppress=0x81,445,0
proc_rlimit_control=0x81,446,0
proc_connectx=0x81,447,0
proc_disconnectx=0x81,448,0
proc_peeloff=0x81,449,0
proc_socket_delegate=0x81,450,0
proc_telemetry=0x81,451,0
proc_uuid_policy=0x81,452,0
memorystatus_get_level=0x81,453,0
system_override=0x81,454,0
vfs_purge=0x81,455,0
sfi_ctl=0x81,456,0
sfi_pidctl=0x81,457,0
coalition=0x81,458,0
coalition_info=0x81,459,0
necp_match_policy=0x81,460,0
getattrlistbulk=0x81,461,0
placeholder for clonefile=0x81,462,0
openat=0x81,463,0
openat_nocancel=0x81,464,0
renameat=0x81,465,0
faccessat=0x81,466,0
fchmodat=0x81,467,0
fchownat=0x81,468,0
fstatat=0x81,469,0
fstatat64=0x81,470,0
linkat=0x81,471,0
unlinkat=0x81,472,0
readlinkat=0x81,473,0
symlinkat=0x81,474,0
mkdirat=0x81,475,0
getattrlistat=0x81,476,0
proc_trace_log=0x81,477,0
bsdthread_ctl=0x81,478,0
openbyid_np=0x81,479,0
recvmsg_x=0x81,480,0
sendmsg_x=0x81,481,0
thread_selfusage=0x81,482,0
guarded_open_dprotected_np=0x81,484,0
guarded_write_np=0x81,485,0
guarded_pwrite_np=0x81,486,0
guarded_writev_np=0x81,487,0
rename_ext=0x81,488,0
mremap_encrypted=0x81,489,0
netagent_trigger=0x81,490,0
stack_snapshot_with_config=0x81,491,0
microstackshot=0x81,492,0
grab_pgo_data=0x81,493,0
persona=0x81,494,0
work_interval_ctl=0x81,499,0
getentropy=0x81,500,0
necp_open=0x81,501,0
necp_client_action=0x81,502,0
__nexus_open=0x81,503,0
__nexus_register=0x81,504,0
__nexus_deregister=0x81,505,0
__nexus_create=0x81,506,0
__nexus_destroy=0x81,507,0
__nexus_get_opt=0x81,508,0
__nexus_set_opt=0x81,509,0
__channel_open=0x81,510,0
__channel_get_info=0x81,511,0
__channel_sync=0x81,512,0
__channel_get_opt=0x81,513,0
__channel_set_opt=0x81,514,0
ulock_wait=0x81,515,0
ulock_wake=0x81,516,0
fclonefileat=0x81,517,0
fs_snapshot=0x81,518,0
terminate_with_payload=0x81,520,0
rizin-0.7.4/librz/syscall/d/dos-x86-16.sdb.txt 0000664 0001750 0001750 00000006114 14731035230 020202 0 ustar sophie sophie _=0x21
TerminateProcess=0x21,0,1,1,i
ReadFromStdinWithEcho=0x21,1,0,i
WriteCharToStdout=0x21,2,0,
ReadCharFromStdaux=0x21,3,0,0,
WriteCharToStdaux=0x21,4,0,0,
WriteCharToPrinter=0x21,5,0,0,
DirectConsoleOutput=0x21,6,0,0,
ReadFromStdin=0x21,7,0,0,
DirectCharInputWithoutEcho=0x21,8,0,0,
WriteStringToStdout=0x21,9,0,0,
BufferedInput=0x21,10,0,0,
GetStdinStatus=0x21,11,0,0,
ReadFromFlushedStdin=0x21,12,0,0,
DiskReset=0x21,13,0,0,
SelectDefaultDrive=0x21,14,0,0,
FCB_OpenFile=0x21,15,0,0,
FCB_CloseFile=0x21,16,0,0,
FCB_FindFirstMatchingFile=0x21,17,0,0,
FCB_FindNextMatchingFile=0x21,18,0,0,
FCB_DeleteFile=0x21,19,0,0,
FCB_ReadSequential=0x21,20,0,0,
FCB_WriteSequential=0x21,21,0,0,
FCB_CreateOrTruncateFile=0x21,22,0,0,
FCB_RenameFile=0x21,23,0,0,
FCB_GetAllocationOfDefaultDrive=0x21,27,0,0,
FCB_GetAllocationOfSpecificDrive=0x21,28,0,0,
FCB_ReadRandomRecord=0x21,33,0,0,
FCB_WriteRandomRecord=0x21,34,0,0,
FCB_GetFileSize=0x21,35,0,0,
FCB_SetRandomRecordNumber=0x21,36,0,0,
FCB_ReadRandomBlock=0x21,39,0,0,
FCB_WriteRandomBlock=0x21,40,0,0,
FCB_ParseFileIntoFCB=0x21,41,0,0,
GetCurrentDefaultDrive=0x21,25,0,0,
SetDiskTransferAddress=0x21,26,0,0,
SetInterruptVector=0x21,37,0,0,
CreateNewPSP=0x21,38,0,0,
GetSystemDate=0x21,42,0,0,
SetSystemDate=0x21,43,0,0,
GetSystemTime=0x21,44,0,0,
SetSystemTime=0x21,45,0,0,
SetVerifyFlag=0x21,46,0,0,
GetDiskTransferArea=0x21,47,0,0,
GetDOSVersion=0x21,48,0,0,
TerminateAndStayResident=0x21,49,0,0,
GetDriveParameterBlockForDefaultDrive=0x21,31,0,0,
GetDriveParameterBlockForSpecificDrive=0x21,50,0,0,
ExtendedBreakCheck=0x21,51,0,0,
GetIndosFlag=0x21,52,0,0,
GetInterruptVector=0x21,53,0,0,
GetFreeDiskSpace=0x21,54,0,0,
GetSetSwitch=0x21,55,0,0,
SetCountryCode=0x21,56,0,0,
CreateDirectory=0x21,57,0,0,
RemoveDirectory=0x21,58,0,0,
SetCurrentDirectory=0x21,59,0,0,
CreateFile=0x21,60,0,0,
OpenFile=0x21,61,0,0,
CloseFile=0x21,62,0,0,
ReadFile=0x21,63,0,0,
WriteFile=0x21,64,0,0,
UnlinkFile=0x21,65,0,0,
Lseek=0x21,66,0,0,
GetSetFileAttributes=0x21,67,0,0,
Ioctl=0x21,68,0,0,
Dup=0x21,69,0,0,
Dup2=0x21,70,0,0,
GetCurrentDirectory=0x21,71,0,0,
AllocateMemory=0x21,72,0,0,
FreeMemory=0x21,73,0,0,
ResizeMemoryBlock=0x21,74,0,0,
ExecuteProgram=0x21,75,0,0,
TerminateProcessWithReturnCode=0x21,76,0,0,
GetReturnCode=0x21,77,0,0,
FindFirstMatchingFile=0x21,78,0,0,
FindNextMatchingFile=0x21,79,0,0,
SetCurrentPSP=0x21,80,0,0,
GetCurrentPSP=0x21,81,0,0,
GetListOfLists=0x21,82,0,0,
TranslateBiosBlock=0x21,83,0,0,
GetVerifyFlag=0x21,84,0,0,
CreateChildPSP=0x21,85,0,0,
RenameFile=0x21,86,0,0,
GetSetFileDateTime=0x21,87,0,0,
GetSetMemoryAllocationStrategy=0x21,88,0,0,
GetExtendedErrorInformation=0x21,89,0,0,
CreateTemporaryFile=0x21,90,0,0,
CreateNewFile=0x21,91,0,0,
FileRegionLock=0x21,92,0,0,
NetworkFunctions=0x21,93,0,0,
NetworkRedirection=0x21,95,0,0,
CanonicalizeFileName=0x21,96,0,0,
GetCurrentPSPAddress=0x21,98,0,0,
DoubleByteCharacterSet=0x21,99,0,0,
SetDeviceDriverLookaheadFlag=0x21,100,0,0,
GetCountryInformation=0x21,101,0,0,
GetSetGlobalCodePageTable=0x21,102,0,0,
SetHandleCount=0x21,103,0,0,
CommitFile=0x21,104,0,0,
GetSetDiskSerialNumber=0x21,105,0,0,
ExtendedOpenCreate=0x21,108,0,0,
rizin-0.7.4/librz/syscall/d/darwin-arm-64.sdb.txt 0000664 0001750 0001750 00000021417 14731035230 021041 0 ustar sophie sophie _=0x80
exit=0x80,1,1,
fork=0x80,2,0
read=0x80,3,3,
write=0x80,4,3,
open=0x80,5,3,
close=0x80,6,1,
wait4=0x80,7,3,
link=0x80,9,2,zz
unlink=0x80,10,1,z
chdir=0x80,12,1,z
fchdir=0x80,13,1,i
mknod=0x80,14,3,zii
chmod=0x80,15,2,zi
chown=0x80,16,3,zii
getfsstat=0x80,18,3,pii
getpid=0x80,20,0,
setuid=0x80,23,1,i
getuid=0x80,24,0,
geteuid=0x80,25,0,
ptrace=0x80,26,4,
recvmsg=0x80,27,3,
sendmsg=0x80,28,3,
recvfrom=0x80,29,3,
accept=0x80,30,1,i
getpeername=0x80,31,0,
getsockname=0x80,32,0,
access=0x80,33,0,
chflags=0x80,34,0
fchflags=0x80,35,0
sync=0x80,36,0
kill=0x80,37,0
getppid=0x80,39,0
dup=0x80,41,0
pipe=0x80,42,0
getegid=0x80,43,0
sigaction=0x80,46,0
getgid=0x80,47,0
sigprocmask=0x80,48,0
getlogin=0x80,49,0
setlogin=0x80,50,0
acct=0x80,51,0
sigpending=0x80,52,0
sigaltstack=0x80,53,0
ioctl=0x80,54,0
reboot=0x80,55,0
revoke=0x80,56,0
symlink=0x80,57,0
readlink=0x80,58,0
execve=0x80,59,0
umask=0x80,60,0
chroot=0x80,61,0
msync=0x80,65,0
vfork=0x80,66,0
munmap=0x80,73,0
mprotect=0x80,74,0
madvise=0x80,75,0
mincore=0x80,78,0
getgroups=0x80,79,0
setgroups=0x80,80,0
getpgrp=0x80,81,0
setpgid=0x80,82,0
setitimer=0x80,83,0
swapon=0x80,85,0
getitimer=0x80,86,0
getdtablesize=0x80,89,0
dup2=0x80,90,0
fcntl=0x80,92,0
select=0x80,93,0
fsync=0x80,95,0
setpriority=0x80,96,0
socket=0x80,97,0
connect=0x80,98,0
getpriority=0x80,100,0
bind=0x80,104,0
setsockopt=0x80,105,0
listen=0x80,106,0
sigsuspend=0x80,111,0
gettimeofday=0x80,116,0
getrusage=0x80,117,0
getsockopt=0x80,118,0
readv=0x80,120,0
writev=0x80,121,0
settimeofday=0x80,122,0
fchown=0x80,123,0
fchmod=0x80,124,0
setreuid=0x80,126,0
setregid=0x80,127,0
rename=0x80,128,0
flock=0x80,131,0
mkfifo=0x80,132,0
sendto=0x80,133,0
shutdown=0x80,134,0
socketpair=0x80,135,0
mkdir=0x80,136,0
rmdir=0x80,137,0
utimes=0x80,138,0
futimes=0x80,139,0
adjtime=0x80,140,0
gethostuuid=0x80,142,0
setsid=0x80,147,0
getpgid=0x80,151,0
setprivexec=0x80,152,0
pread=0x80,153,0
pwrite=0x80,154,0
statfs=0x80,157,0
fstatfs=0x80,158,0
unmount=0x80,159,0
quotactl=0x80,165,0
mount=0x80,167,0
csops=0x80,169,0
170=0x80,170,0
waitid=0x80,173,0
kdebug_trace=0x80,180,0
setgid=0x80,181,0
setegid=0x80,182,0
seteuid=0x80,183,0
sigreturn=0x80,184,0
chud=0x80,185,0
fdatasync=0x80,187,0
stat=0x80,188,0
fstat=0x80,189,0
lstat=0x80,190,0
pathconf=0x80,191,0
fpathconf=0x80,192,0
getrlimit=0x80,194,0
setrlimit=0x80,195,0
getdirentries=0x80,196,0
mmap=0x80,197,0
lseek=0x80,199,0
truncate=0x80,200,0
ftruncate=0x80,201,0
__sysctl=0x80,202,0
mlock=0x80,203,0
munlock=0x80,204,0
undelete=0x80,205,0
mkcomplex=0x80,216,0
getattrlist=0x80,220,0
setattrlist=0x80,221,0
getdirentriesattr=0x80,222,0
exchangedata=0x80,223,0
searchfs=0x80,225,0
delete=0x80,226,0
copyfile=0x80,227,0
fgetattrlist=0x80,228,0
fsetattrlist=0x80,229,0
poll=0x80,230,0
watchevent=0x80,231,0
waitevent=0x80,232,0
modwatch=0x80,233,0
getxattr=0x80,234,0
fgetxattr=0x80,235,0
setxattr=0x80,236,0
fsetxattr=0x80,237,0
removexattr=0x80,238,0
fremovexattr=0x80,239,0
listxattr=0x80,240,0
flistxattr=0x80,241,0
fsctl=0x80,242,0
initgroups=0x80,243,0
posix_spawn=0x80,244,0
ffsctl=0x80,245,0
minherit=0x80,250,0
shm_open=0x80,266,0
shm_unlink=0x80,267,0
sem_open=0x80,268,0
sem_close=0x80,269,0
sem_unlink=0x80,270,0
sem_wait=0x80,271,0
sem_trywait=0x80,272,0
sem_post=0x80,273,0
sem_getvalue=0x80,274,0
sem_init=0x80,275,0
sem_destroy=0x80,276,0
open_extended=0x80,277,0
umask_extended=0x80,278,0
stat_extended=0x80,279,0
lstat_extended=0x80,280,0
fstat_extended=0x80,281,0
chmod_extended=0x80,282,0
fchmod_extended=0x80,283,0
access_extended=0x80,284,0
settid=0x80,285,0
gettid=0x80,286,0
setsgroups=0x80,287,0
getsgroups=0x80,288,0
setwgroups=0x80,289,0
getwgroups=0x80,290,0
mkfifo_extended=0x80,291,0
mkdir_extended=0x80,292,0
shared_region_check_np=0x80,294,0
vm_pressure_monitor=0x80,296,0
psynch_rw_longrdlock=0x80,297,0
psynch_rw_yieldwrlock=0x80,298,0
psynch_rw_downgrade=0x80,299,0
psynch_rw_upgrade=0x80,300,0
psynch_mutexwait=0x80,301,0
psynch_mutexdrop=0x80,302,0
psynch_cvbroad=0x80,303,0
psynch_cvsignal=0x80,304,0
psynch_cvwait=0x80,305,0
psynch_rw_rdlock=0x80,306,0
psynch_rw_wrlock=0x80,307,0
psynch_rw_unlock=0x80,308,0
psynch_rw_unlock2=0x80,309,0
getsid=0x80,310,0
settid_with_pid=0x80,311,0
psynch_cvclrprepost=0x80,312,0
aio_fsync=0x80,313,0
aio_return=0x80,314,0
aio_suspend=0x80,315,0
aio_cancel=0x80,316,0
aio_error=0x80,317,0
aio_read=0x80,318,0
aio_write=0x80,319,0
lio_listio=0x80,320,0
iopolicysys=0x80,322,0
process_policy=0x80,323,0
mlockall=0x80,324,0
munlockall=0x80,325,0
issetugid=0x80,327,0
__pthread_kill=0x80,328,0
__pthread_sigmask=0x80,329,0
__sigwait=0x80,330,0
__disable_threadsignal=0x80,331,0
__pthread_markcancel=0x80,332,0
__pthread_canceled=0x80,333,0
__semwait_signal=0x80,334,0
proc_info=0x80,336,0
stat64=0x80,338,0
fstat64=0x80,339,0
lstat64=0x80,340,0
stat64_extended=0x80,341,0
lstat64_extended=0x80,342,0
fstat64_extended=0x80,343,0
getdirentries64=0x80,344,0
statfs64=0x80,345,0
fstatfs64=0x80,346,0
getfsstat64=0x80,347,0
__pthread_chdir=0x80,348,0
__pthread_fchdir=0x80,349,0
audit=0x80,350,0
auditon=0x80,351,0
getauid=0x80,353,0
setauid=0x80,354,0
getaudit_addr=0x80,357,0
setaudit_addr=0x80,358,0
auditctl=0x80,359,0
bsdthread_create=0x80,360,0
bsdthread_terminate=0x80,361,0
kqueue=0x80,362,0
kevent=0x80,363,0
lchown=0x80,364,0
stack_snapshot=0x80,365,0
bsdthread_register=0x80,366,0
workq_open=0x80,367,0
workq_kernreturn=0x80,368,0
kevent64=0x80,369,7,
__old_semwait_signal=0x80,370,0
__old_semwait_signal_nocancel=0x80,371,0
thread_selfid=0x80,372,0
ledger=0x80,373,0
__mac_execve=0x80,380,0
__mac_syscall=0x80,381,0
__mac_get_file=0x80,382,0
__mac_set_file=0x80,383,0
__mac_get_link=0x80,384,0
__mac_set_link=0x80,385,0
__mac_get_proc=0x80,386,0
__mac_set_proc=0x80,387,0
__mac_get_fd=0x80,388,0
__mac_set_fd=0x80,389,0
__mac_get_pid=0x80,390,0
__mac_get_lcid=0x80,391,0
__mac_get_lctx=0x80,392,0
__mac_set_lctx=0x80,393,0
setlcid=0x80,394,0
getlcid=0x80,395,0
read_nocancel=0x80,396,0
write_nocancel=0x80,397,0
open_nocancel=0x80,398,0
close_nocancel=0x80,399,0
wait4_nocancel=0x80,400,0
recvmsg_nocancel=0x80,401,0
sendmsg_nocancel=0x80,402,0
recvfrom_nocancel=0x80,403,0
accept_nocancel=0x80,404,0
msync_nocancel=0x80,405,0
fcntl_nocancel=0x80,406,0
select_nocancel=0x80,407,0
fsync_nocancel=0x80,408,0
connect_nocancel=0x80,409,0
sigsuspend_nocancel=0x80,410,0
readv_nocancel=0x80,411,0
writev_nocancel=0x80,412,0
sendto_nocancel=0x80,413,0
pread_nocancel=0x80,414,0
pwrite_nocancel=0x80,415,0
waitid_nocancel=0x80,416,0
poll_nocancel=0x80,417,0
sem_wait_nocancel=0x80,420,0
aio_suspend_nocancel=0x80,421,0
__sigwait_nocancel=0x80,422,0
__semwait_signal_nocancel=0x80,423,0
__mac_mount=0x80,424,0
__mac_get_mount=0x80,425,0
__mac_getfsstat=0x80,426,0
fsgetpath=0x80,427,0
audit_session_self=0x80,428,0
audit_session_join=0x80,429,0
fileport_makeport=0x80,430,0
fileport_makefd=0x80,431,0
audit_session_port=0x80,432,0
pid_suspend=0x80,433,0
pid_resume=0x80,434,0
pid_hibernate=0x80,435,0
pid_shutdown_sockets=0x80,436,0
shared_region_map_and_slide_np=0x80,438,0
kas_info=0x80,439,0
memorystatus_control=0x80,440,0
guarded_open_np=0x80,441,0
guarded_close_np=0x80,442,0
guarded_kqueue_np=0x80,443,0
change_fdguard_np=0x80,444,0
old __proc_suppress=0x80,445,0
proc_rlimit_control=0x80,446,0
proc_connectx=0x80,447,0
proc_disconnectx=0x80,448,0
proc_peeloff=0x80,449,0
proc_socket_delegate=0x80,450,0
proc_telemetry=0x80,451,0
proc_uuid_policy=0x80,452,0
memorystatus_get_level=0x80,453,0
system_override=0x80,454,0
vfs_purge=0x80,455,0
sfi_ctl=0x80,456,0
sfi_pidctl=0x80,457,0
coalition=0x80,458,0
coalition_info=0x80,459,0
necp_match_policy=0x80,460,0
getattrlistbulk=0x80,461,0
placeholder for clonefile=0x80,462,0
openat=0x80,463,0
openat_nocancel=0x80,464,0
renameat=0x80,465,0
faccessat=0x80,466,0
fchmodat=0x80,467,0
fchownat=0x80,468,0
fstatat=0x80,469,0
fstatat64=0x80,470,0
linkat=0x80,471,0
unlinkat=0x80,472,0
readlinkat=0x80,473,0
symlinkat=0x80,474,0
mkdirat=0x80,475,0
getattrlistat=0x80,476,0
proc_trace_log=0x80,477,0
bsdthread_ctl=0x80,478,0
openbyid_np=0x80,479,0
recvmsg_x=0x80,480,0
sendmsg_x=0x80,481,0
thread_selfusage=0x80,482,0
guarded_open_dprotected_np=0x80,484,0
guarded_write_np=0x80,485,0
guarded_pwrite_np=0x80,486,0
guarded_writev_np=0x80,487,0
rename_ext=0x80,488,0
mremap_encrypted=0x80,489,0
netagent_trigger=0x80,490,0
stack_snapshot_with_config=0x80,491,0
microstackshot=0x80,492,0
grab_pgo_data=0x80,493,0
persona=0x80,494,0
work_interval_ctl=0x80,499,0
getentropy=0x80,500,0
necp_open=0x80,501,0
necp_client_action=0x80,502,0
__nexus_open=0x80,503,0
__nexus_register=0x80,504,0
__nexus_deregister=0x80,505,0
__nexus_create=0x80,506,0
__nexus_destroy=0x80,507,0
__nexus_get_opt=0x80,508,0
__nexus_set_opt=0x80,509,0
__channel_open=0x80,510,0
__channel_get_info=0x80,511,0
__channel_sync=0x80,512,0
__channel_get_opt=0x80,513,0
__channel_set_opt=0x80,514,0
ulock_wait=0x80,515,0
ulock_wake=0x80,516,0
fclonefileat=0x80,517,0
fs_snapshot=0x80,518,0
terminate_with_payload=0x80,520,0
rizin-0.7.4/librz/syscall/d/linux-arm-64.sdb.txt 0000664 0001750 0001750 00000012017 14731035230 020710 0 ustar sophie sophie _=0x0
io_setup=0,0
io_destroy=0,1
io_submit=0,2
io_cancel=0,3
io_getevents=0,4
setxattr=0,5
lsetxattr=0,6
fsetxattr=0,7
getxattr=0,8
lgetxattr=0,9
fgetxattr=0,10
listxattr=0,11
llistxattr=0,12
flistxattr=0,13
removexattr=0,14
lremovexattr=0,15
fremovexattr=0,16
getcwd=0,17
lookup_dcookie=0,18
eventfd2=0,19
epoll_create1=0,20
epoll_ctl=0,21
epoll_pwait=0,22
dup=0,23
dup3=0,24
fcntl=0,25
inotify_init1=0,26
inotify_add_watch=0,27
inotify_rm_watch=0,28
ioctl=0,29
ioprio_set=0,30
ioprio_get=0,31
flock=0,32
mknodat=0,33
mkdirat=0,34
unlinkat=0,35
symlinkat=0,36
linkat=0,37
renameat=0,38
umount2=0,39
mount=0,40
pivot_root=0,41
nfsservctl=0,42
statfs=0,43
fstatfs=0,44
truncate=0,45
ftruncate=0,46
fallocate=0,47
faccessat=0,48
chdir=0,49,1,z
fchdir=0,50,1,i
chroot=0,51,1,z
fchmod=0,52
fchmodat=0,53
fchownat=0,54
fchown=0,55
openat=0,56
close=0,57,1,i
vhangup=0,58
pipe2=0,59
quotactl=0,60
getdents64=0,61
lseek=0,62
read=0,63,3,ipi
write=0,64,3,izi
readv=0,65
writev=0,66
pread64=0,67
pwrite64=0,68
preadv=0,69
pwritev=0,70
sendfile=0,71
pselect6=0,72
ppoll=0,73
signalfd4=0,74
vmsplice=0,75
splice=0,76
tee=0,77
readlinkat=0,78
fstatat=0,79
fstat=0,80
sync=0,81
fsync=0,82
fdatasync=0,83
sync_file_range=0,84
timerfd_create=0,85
timerfd_settime=0,86
timerfd_gettime=0,87
utimensat=0,88
acct=0,89
capget=0,90
capset=0,91
personality=0,92
exit=0,93,1,i
exit_group=0,94
waitid=0,95
set_tid_address=0,96
unshare=0,97
futex=0,98
set_robust_list=0,99
get_robust_list=0,100
nanosleep=0,101
getitimer=0,102
setitimer=0,103
kexec_load=0,104
init_module=0,105
delete_module=0,106
timer_create=0,107
timer_gettime=0,108
timer_getoverrun=0,109
timer_settime=0,110
timer_delete=0,111
clock_settime=0,112
clock_gettime=0,113
clock_getres=0,114
clock_nanosleep=0,115
syslog=0,116
ptrace=0,117
sched_setparam=0,118
sched_setscheduler=0,119
sched_getscheduler=0,120
sched_getparam=0,121
sched_setaffinity=0,122
sched_getaffinity=0,123
sched_yield=0,124
sched_get_priority_max=0,125
sched_get_priority_min=0,126
sched_rr_get_interval=0,127
restart_syscall=0,128
kill=0,129
tkill=0,130
tgkill=0,131
sigaltstack=0,132
rt_sigsuspend=0,133
rt_sigaction=0,134
rt_sigprocmask=0,135
rt_sigpending=0,136
rt_sigtimedwait=0,137
rt_sigqueueinfo=0,138
rt_sigreturn=0,139
setpriority=0,140
getpriority=0,141
reboot=0,142
setregid=0,143
setgid=0,144
setreuid=0,145
setuid=0,146
setresuid=0,147
getresuid=0,148
setresgid=0,149
getresgid=0,150
setfsuid=0,151
setfsgid=0,152
times=0,153
setpgid=0,154
getpgid=0,155
getsid=0,156
setsid=0,157
getgroups=0,158
setgroups=0,159
uname=0,160
sethostname=0,161
setdomainname=0,162
getrlimit=0,163
setrlimit=0,164
getrusage=0,165
umask=0,166
prctl=0,167
getcpu=0,168
gettimeofday=0,169
settimeofday=0,170
adjtimex=0,171
getpid=0,172,0
getppid=0,173,0
getuid=0,174,0
geteuid=0,175,0
getgid=0,176,0
getegid=0,177,0
gettid=0,178,0
sysinfo=0,179,0
mq_open=0,180
mq_unlink=0,181,1,z
mq_timedsend=0,182
mq_timedreceive=0,183
mq_notify=0,184
mq_getsetattr=0,185
msgget=0,186
msgctl=0,187
msgrcv=0,188
msgsnd=0,189
semget=0,190
semctl=0,191
semtimedop=0,192
semop=0,193
shmget=0,194
shmctl=0,195
shmat=0,196
shmdt=0,197
socket=0,198
socketpair=0,199
bind=0,200
listen=0,201
accept=0,202
connect=0,203
getsockname=0,204
getpeername=0,205
sendto=0,206
recvfrom=0,207
setsockopt=0,208
getsockopt=0,209
shutdown=0,210
sendmsg=0,211
recvmsg=0,212
readahead=0,213
brk=0,214
munmap=0,215
mremap=0,216
add_key=0,217
request_key=0,218
keyctl=0,219
clone=0,220
execve=0,221
mmap=0,222
fadvise64=0,223
swapon=0,224
swapoff=0,225
mprotect=0,226
msync=0,227
mlock=0,228
munlock=0,229
mlockall=0,230
munlockall=0,231
mincore=0,232
madvise=0,233
remap_file_pages=0,234
mbind=0,235
get_mempolicy=0,236
set_mempolicy=0,237
migrate_pages=0,238
move_pages=0,239
rt_tgsigqueueinfo=0,240
perf_event_open=0,241
accept4=0,242
recvmmsg=0,243
arch_specific_syscall=0,244
wait4=0,260
prlimit64=0,261
fanotify_init=0,262
fanotify_mark=0,263
name_to_handle_at=0,264
open_by_handle_at=0,265
clock_adjtime=0,266
syncfs=0,267
setns=0,268
sendmmsg=0,269
process_vm_readv=0,270
process_vm_writev=0,271
kcmp=0,272
finit_module=0,273
sched_setattr=0,274
sched_getattr=0,275
renameat2=0,276,5,
seccomp=0,277,3,
getrandom=0,278,3,pii
memfd_create=0,279,2,
bpf=0,280,3,
execveat=0,281,5,
userfaultfd=0,282,1,
membarrier=0,283,2,
mlock2=0,284,3,
copy_file_range=0,285,6,
preadv2=0,286,6,
pwritev2=0,287,6,
pkey_mprotect=0,288,4,
pkey_alloc=0,289,2,
pkey_free=0,290,1,
statx=0,291,5,
io_pgetevents=0,292,6,
rseq=0,293,4,
kexec_file_load=0,294,5,
pidfd_send_signal=0,424,4,
io_uring_setup=0,425,2,
io_uring_enter=0,426,5,
io_uring_register=0,427,4,
open_tree=0,428,3,
move_mount=0,429,5,
fsopen=0,430,2,
fsconfig=0,431,5,
fsmount=0,432,3,
fspick=0,433,3,
pidfd_open=0,434,2,
clone3=0,435,2,
close_range=0,436,3,
openat2=0,437,4,
pidfd_getfd=0,438,3,
faccessat2=0,439,4,
process_madvise=0,440,5,
epoll_pwait2=0,441,6,
mount_setattr=0,442,5,
quotactl_fd=0,443,4,
landlock_create_ruleset=0,444,3,
landlock_add_rule=0,445,4,
landlock_restrict_self=0,446,2,
memfd_secret=0,447,1,
process_mrelease=0,448,2,
futex_waitv=0,449,5,
set_mempolicy_home_node=0,450,4,
cachestat=0,451,4,
rizin-0.7.4/librz/syscall/d/freebsd-x86-32.sdb.txt 0000664 0001750 0001750 00000002546 14731035230 021032 0 ustar sophie sophie _=0x80
syscall=0x80,0,4,sysnum
exit=0x80,1,1,
fork=0x80,2,0,
read=0x80,3,3,
write=0x80,4,3,
open=0x80,5,3,
close=0x80,6,1,
wait4=0x80,7,3,
old_creat=0x80,8,2,
link=0x80,9,2,
unlink=0x80,10,1,
old_execve=0x80,11,3,
chdir=0x80,12,1,
fchdir=0x80,13,1,
mknod=0x80,14,1,
chmod=0x80,15,1,
chown=0x80,16,1,
break=0x80,17,1,
old_fsstat=0x80,18,1,
old_lseek=0x80,19,1,
getpid=0x80,20,0,
mount=0x80,21,0,
unmount=0x80,22,0,
setuid=0x80,23,1,
getuid=0x80,24,0,
ptrace=0x80,26,4,
recvmsg=0x80,27,4,
sendmsg=0x80,28,4,
recvfrom=0x80,29,4,
accept=0x80,30,4,
getpeername=0x80,31,3,
getsockname=0x80,32,3,
access=0x80,33,2,
chflags=0x80,34,2,
fchflags=0x80,35,2,
sync=0x80,36,0,
kill=0x80,37,2,
dup=0x80,41,2,
pipe=0x80,42,1,
getepid=0x80,43,0,
profil=0x80,44,4,/*
ktrace=0x80,45,4,
getgid=0x80,47,0,
signal=0x80,48,2,
getlogin=0x80,49,0,/*
setlogin=0x80,50,1,/*
acct=0x80,51,1,/*
sigaltstack=0x80,53,2,/*
ioctl=0x80,54,3,
reboot=0x80,55,1,
revoke=0x80,56,1,/*
symlink=0x80,57,2,
readlink=0x80,58,1,
execve=0x80,59,2,
umask=0x80,60,1,
chroot=0x80,61,1,
mmap=0x80,90,6,
munmap=0x80,91,1,
socketcall=0x80,102,2,
sigreturn=0x80,119,1,
clone=0x80,120,4,
mprotect=0x80,125,3,
rt_sigaction=0x80,174,3,
rt_sigprocmask=0x80,175,3,
sysctl=0x80,149,1,
mmap2=0x80,192,6,
fstat64=0x80,197,2,
fcntl64=0x80,221,3,
gettid=0x80,224,0,
set_thread_area=0x80,243,2,
get_thread_area=0x80,244,2,
exit_group=0x80,252,1,
rizin-0.7.4/librz/syscall/d/openbsd-x86-64.sdb.txt 0000664 0001750 0001750 00000007207 14731035230 021056 0 ustar sophie sophie _=0x80
syscall=0x80,0,2,
exit=0x80,1,1,
fork=0x80,2,0,
read=0x80,3,3,
write=0x80,4,3,
open=0x80,5,3,
close=0x80,6,1,
wait4=0x80,7,4,
link=0x80,9,2,
unlink=0x80,10,1,
chdir=0x80,12,1,
fchdir=0x80,13,1,
mknod=0x80,14,3,
chmod=0x80,15,2,
chown=0x80,16,3,
break=0x80,17,1,
getpid=0x80,20,0,
mount=0x80,21,4,
unmount=0x80,22,2,
setuid=0x80,23,1,
getuid=0x80,24,0,
geteuid=0x80,25,0,
ptrace=0x80,26,4,
recvmsg=0x80,27,3,
sendmsg=0x80,28,3,
recvfrom=0x80,29,6,
accept=0x80,30,3,
getpeername=0x80,31,3,
getsockname=0x80,32,3,
access=0x80,33,2,
chflags=0x80,34,2,
fchflags=0x80,35,2,
sync=0x80,36,0,
kill=0x80,37,2,
getppid=0x80,39,0,
dup=0x80,41,1,
opipe=0x80,42,0,
getegid=0x80,43,0,
profil=0x80,44,4,
ktrace=0x80,45,4,
sigaction=0x80,46,3,
getgid=0x80,47,0,
sigprocmask=0x80,48,2,
getlogin=0x80,49,2,
setlogin=0x80,50,1,
acct=0x80,51,1,
sigpending=0x80,52,0,
osigaltstack=0x80,53,2,
ioctl=0x80,54,3,
reboot=0x80,55,1,
revoke=0x80,56,1,
symlink=0x80,57,2,
readlink=0x80,58,3,
execve=0x80,59,3,
umask=0x80,60,1,
chroot=0x80,61,1,
vfork=0x80,66,0,
sbrk=0x80,69,1,
sstk=0x80,70,1,
munmap=0x80,73,2,
mprotect=0x80,74,3,
madvise=0x80,75,3,
mincore=0x80,78,3,
getgroups=0x80,79,2,
setgroups=0x80,80,2,
getpgrp=0x80,81,0,
setpgid=0x80,82,2,
setitimer=0x80,83,3,
getitimer=0x80,86,2,
dup2=0x80,90,2,
fcntl=0x80,92,3,
select=0x80,93,5,
fsync=0x80,95,1,
setpriority=0x80,96,3,
socket=0x80,97,3,
connect=0x80,98,3,
getpriority=0x80,100,2,
sigreturn=0x80,103,1,
bind=0x80,104,3,
setsockopt=0x80,105,5,
listen=0x80,106,2,
sigsuspend=0x80,111,1,
gettimeofday=0x80,116,2,
getrusage=0x80,117,2,
getsockopt=0x80,118,5,
readv=0x80,120,3,
writev=0x80,121,3,
settimeofday=0x80,122,2,
fchown=0x80,123,3,
fchmod=0x80,124,2,
setreuid=0x80,126,2,
setregid=0x80,127,2,
rename=0x80,128,2,
flock=0x80,131,2,
mkfifo=0x80,132,2,
sendto=0x80,133,6,
shutdown=0x80,134,2,
socketpair=0x80,135,4,
mkdir=0x80,136,2,
rmdir=0x80,137,1,
utimes=0x80,138,2,
adjtime=0x80,140,2,
setsid=0x80,147,0,
quotactl=0x80,148,4,
nfssvc=0x80,155,2,
getfh=0x80,161,2,
sysarch=0x80,165,2,
pread=0x80,173,5,
pwrite=0x80,174,5,
setgid=0x80,181,1,
setegid=0x80,182,1,
seteuid=0x80,183,1,
lfs_bmapv=0x80,184,3,
lfs_markv=0x80,185,3,
lfs_segclean=0x80,186,2,
lfs_segwait=0x80,187,2,
pathconf=0x80,191,2,
fpathconf=0x80,192,2,
swapctl=0x80,193,3,
getrlimit=0x80,194,2,
setrlimit=0x80,195,2,
getdirentries=0x80,196,4,
mmap=0x80,197,7,
__syscall=0x80,198,2,
lseek=0x80,199,4,
truncate=0x80,200,3,
ftruncate=0x80,201,3,
__sysctl=0x80,202,6,
mlock=0x80,203,2,
munlock=0x80,204,2,
futimes=0x80,206,2,
getpgid=0x80,207,1,
nnpfspioctl=0x80,208,5,
semget=0x80,221,3,
msgget=0x80,225,2,
msgsnd=0x80,226,4,
msgrcv=0x80,227,5,
shmat=0x80,228,3,
shmdt=0x80,230,1,
clock_gettime=0x80,232,2,
clock_settime=0x80,233,2,
clock_getres=0x80,234,2,
nanosleep=0x80,240,2,
minherit=0x80,250,3,
rfork=0x80,251,1,
poll=0x80,252,3,
issetugid=0x80,253,0,
lchown=0x80,254,3,
getsid=0x80,255,1,
msync=0x80,256,3,
pipe=0x80,263,1,
fhopen=0x80,264,2,
preadv=0x80,267,5,
pwritev=0x80,268,5,
kqueue=0x80,269,0,
kevent=0x80,270,6,
mlockall=0x80,271,1,
munlockall=0x80,272,0,
getpeereid=0x80,273,3,
getresuid=0x80,281,3,
setresuid=0x80,282,3,
getresgid=0x80,283,3,
setresgid=0x80,284,3,
mquery=0x80,286,7,
closefrom=0x80,287,1,
sigaltstack=0x80,288,2,
shmget=0x80,289,3,
semop=0x80,290,3,
stat=0x80,291,2,
fstat=0x80,292,2,
lstat=0x80,293,2,
fhstat=0x80,294,2,
__semctl=0x80,295,4,
shmctl=0x80,296,3,
msgctl=0x80,297,3,
sched_yield=0x80,298,0,
getthrid=0x80,299,0,
thrsleep=0x80,300,4,
thrwakeup=0x80,301,2,
threxit=0x80,302,1,
thrsigdivert=0x80,303,3,
__getcwd=0x80,304,2,
adjfreq=0x80,305,2,
getfsstat=0x80,306,3,
statfs=0x80,307,2,
fstatfs=0x80,308,2,
fhstatfs=0x80,309,2,
setrtable=0x80,310,1,
getrtable=0x80,311,0,
rizin-0.7.4/librz/syscall/d/windows-x86-64.sdb.txt 0000664 0001750 0001750 00000131201 14731035230 021106 0 ustar sophie sophie NtAcceptConnectPort=0x2e,0x0000,6,
NtAccessCheck=0x2e,0x0001,8,
NtAccessCheckAndAuditAlarm=0x2e,0x0002,11,
NtAccessCheckByType=0x2e,0x0003,11,
NtAccessCheckByTypeAndAuditAlarm=0x2e,0x0004,16,
NtAccessCheckByTypeResultList=0x2e,0x0005,11,
NtAccessCheckByTypeResultListAndAuditAlarm=0x2e,0x0006,16,
NtAccessCheckByTypeResultListAndAuditAlarmByPlugin=0x2e,0x0007,17,
NtAddAtom=0x2e,0x0008,3,
NtAddBootEntry=0x2e,0x0009,2,
NtAddDriverEntry=0x2e,0x000a,2,
NtAdjustGroupsToken=0x2e,0x000b,6,
NtAdjustPrivilegesToken=0x2e,0x000c,6,
NtAlertResumeThread=0x2e,0x000d,2,
NtAlertThread=0x2e,0x000e,1,
NtAllocateLocallyUniqueId=0x2e,0x000f,1,
NtAllocateReserveObject=0x2e,0x0010,3,
NtAllocateUserPhysicalPages=0x2e,0x0011,3,
NtAllocateUuids=0x2e,0x0012,4,
NtAllocateVirtualMemory=0x2e,0x0013,6,
NtAlpcAcceptConnectPort=0x2e,0x0014,9,
NtAlpcCancelMessage=0x2e,0x0015,3,
NtAlpcConnectPort=0x2e,0x0016,11,
NtAlpcCreatePort=0x2e,0x0017,3,
NtAlpcCreatePortSection=0x2e,0x0018,6,
NtAlpcCreateResourceReserve=0x2e,0x0019,4,
NtAlpcCreateSectionView=0x2e,0x001a,3,
NtAlpcCreateSecurityContext=0x2e,0x001b,3,
NtAlpcDeletePortSection=0x2e,0x001c,3,
NtAlpcDeleteResourceReserve=0x2e,0x001d,3,
NtAlpcDeleteSectionView=0x2e,0x001e,3,
NtAlpcDeleteSecurityContext=0x2e,0x001f,3,
NtAlpcDisconnectPort=0x2e,0x0020,2,
NtAlpcImpersonateClientOfPort=0x2e,0x0021,3,
NtAlpcOpenSenderProcess=0x2e,0x0022,6,
NtAlpcOpenSenderThread=0x2e,0x0023,6,
NtAlpcQueryInformation=0x2e,0x0024,5,
NtAlpcQueryInformationMessage=0x2e,0x0025,6,
NtAlpcRevokeSecurityContext=0x2e,0x0026,3,
NtAlpcSendWaitReceivePort=0x2e,0x0027,8,
NtAlpcSetInformation=0x2e,0x0028,4,
NtApphelpCacheControl=0x2e,0x0029,2,
NtAreMappedFilesTheSame=0x2e,0x002a,2,
NtAssignProcessToJobObject=0x2e,0x002b,2,
NtCallbackReturn=0x2e,0x002c,3,
NtCancelIoFile=0x2e,0x002d,2,
NtCancelIoFileEx=0x2e,0x002e,3,
NtCancelSynchronousIoFile=0x2e,0x002f,3,
NtCancelTimer=0x2e,0x0030,2,
NtClearEvent=0x2e,0x0031,1,
NtClose=0x2e,0x0032,1,
NtCloseObjectAuditAlarm=0x2e,0x0033,3,
NtCommitComplete=0x2e,0x0034,2,
NtCommitEnlistment=0x2e,0x0035,2,
NtCommitTransaction=0x2e,0x0036,2,
NtCompactKeys=0x2e,0x0037,2,
NtCompareTokens=0x2e,0x0038,3,
NtCompleteConnectPort=0x2e,0x0039,1,
NtCompressKey=0x2e,0x003a,1,
NtConnectPort=0x2e,0x003b,8,
NtContinue=0x2e,0x003c,2,
NtCreateDebugObject=0x2e,0x003d,4,
NtCreateDirectoryObject=0x2e,0x003e,3,
NtCreateEnlistment=0x2e,0x003f,8,
NtCreateEvent=0x2e,0x0040,5,
NtCreateEventPair=0x2e,0x0041,3,
NtCreateFile=0x2e,0x0042,11,
NtCreateIoCompletion=0x2e,0x0043,4,
NtCreateJobObject=0x2e,0x0044,3,
NtCreateJobSet=0x2e,0x0045,3,
NtCreateKey=0x2e,0x0046,7,
NtCreateKeyedEvent=0x2e,0x0047,4,
NtCreateKeyTransacted=0x2e,0x0048,8,
NtCreateMailslotFile=0x2e,0x0049,8,
NtCreateMutant=0x2e,0x004a,4,
NtCreateNamedPipeFile=0x2e,0x004b,14,
NtCreatePagingFile=0x2e,0x004c,4,
NtCreatePort=0x2e,0x004d,5,
NtCreatePrivateNamespace=0x2e,0x004e,4,
NtCreateProcess=0x2e,0x004f,8,
NtCreateProcessEx=0x2e,0x0050,9,
NtCreateProfile=0x2e,0x0051,9,
NtCreateProfileEx=0x2e,0x0052,10,
NtCreateResourceManager=0x2e,0x0053,7,
NtCreateSection=0x2e,0x0054,7,
NtCreateSemaphore=0x2e,0x0055,5,
NtCreateSymbolicLinkObject=0x2e,0x0056,4,
NtCreateThread=0x2e,0x0057,8,
NtCreateThreadEx=0x2e,0x0058,11,
NtCreateTimer=0x2e,0x0059,4,
NtCreateToken=0x2e,0x005a,13,
NtCreateTransaction=0x2e,0x005b,10,
NtCreateTransactionManager=0x2e,0x005c,6,
NtCreateUserProcess=0x2e,0x005d,11,
NtCreateWaitablePort=0x2e,0x005e,5,
NtCreateWorkerFactory=0x2e,0x005f,10,
NtDebugActiveProcess=0x2e,0x0060,2,
NtDebugContinue=0x2e,0x0061,3,
NtDelayExecution=0x2e,0x0062,2,
NtDeleteAtom=0x2e,0x0063,1,
NtDeleteBootEntry=0x2e,0x0064,1,
NtDeleteDriverEntry=0x2e,0x0065,1,
NtDeleteFile=0x2e,0x0066,1,
NtDeleteKey=0x2e,0x0067,1,
NtDeleteObjectAuditAlarm=0x2e,0x0068,3,
NtDeletePrivateNamespace=0x2e,0x0069,1,
NtDeleteValueKey=0x2e,0x006a,2,
NtDeviceIoControlFile=0x2e,0x006b,10,
NtDisableLastKnownGood=0x2e,0x006c,0,
NtDisplayString=0x2e,0x006d,1,
NtDrawText=0x2e,0x006e,1,
NtDuplicateObject=0x2e,0x006f,7,
NtDuplicateToken=0x2e,0x0070,6,
NtEnableLastKnownGood=0x2e,0x0071,0,
NtEnumerateBootEntries=0x2e,0x0072,2,
NtEnumerateDriverEntries=0x2e,0x0073,2,
NtEnumerateKey=0x2e,0x0074,6,
NtEnumerateSystemEnvironmentValuesEx=0x2e,0x0075,3,
NtEnumerateTransactionObject=0x2e,0x0076,5,
NtEnumerateValueKey=0x2e,0x0077,6,
NtExtendSection=0x2e,0x0078,2,
NtFilterToken=0x2e,0x0079,6,
NtFindAtom=0x2e,0x007a,3,
NtFlushBuffersFile=0x2e,0x007b,2,
NtFlushInstallUILanguage=0x2e,0x007c,2,
NtFlushInstructionCache=0x2e,0x007d,3,
NtFlushKey=0x2e,0x007e,1,
NtFlushProcessWriteBuffers=0x2e,0x007f,0,
NtFlushVirtualMemory=0x2e,0x0080,4,
NtFlushWriteBuffer=0x2e,0x0081,0,
NtFreeUserPhysicalPages=0x2e,0x0082,3,
NtFreeVirtualMemory=0x2e,0x0083,4,
NtFreezeRegistry=0x2e,0x0084,1,
NtFreezeTransactions=0x2e,0x0085,2,
NtFsControlFile=0x2e,0x0086,10,
NtGetContextThread=0x2e,0x0087,2,
NtGetCurrentProcessorNumber=0x2e,0x0088,0,
NtGetDevicePowerState=0x2e,0x0089,2,
NtGetMUIRegistryInfo=0x2e,0x008a,3,
NtGetNextProcess=0x2e,0x008b,5,
NtGetNextThread=0x2e,0x008c,6,
NtGetNlsSectionPtr=0x2e,0x008d,5,
NtGetNotificationResourceManager=0x2e,0x008e,7,
NtGetPlugPlayEvent=0x2e,0x008f,4,
NtGetWriteWatch=0x2e,0x0090,7,
NtImpersonateAnonymousToken=0x2e,0x0091,1,
NtImpersonateClientOfPort=0x2e,0x0092,2,
NtImpersonateThread=0x2e,0x0093,3,
NtInitializeNlsFiles=0x2e,0x0094,3,
NtInitializeRegistry=0x2e,0x0095,1,
NtInitiatePowerAction=0x2e,0x0096,4,
NtIsProcessInJob=0x2e,0x0097,2,
NtIsSystemResumeAutomatic=0x2e,0x0098,0,
NtIsUILanguageComitted=0x2e,0x0099,0,
NtListenPort=0x2e,0x009a,2,
NtLoadDriver=0x2e,0x009b,1,
NtLoadKey=0x2e,0x009c,2,
NtLoadKey2=0x2e,0x009d,3,
NtLoadKeyEx=0x2e,0x009e,8,
NtLockFile=0x2e,0x009f,10,
NtLockProductActivationKeys=0x2e,0x00a0,2,
NtLockRegistryKey=0x2e,0x00a1,1,
NtLockVirtualMemory=0x2e,0x00a2,4,
NtMakePermanentObject=0x2e,0x00a3,1,
NtMakeTemporaryObject=0x2e,0x00a4,1,
NtMapCMFModule=0x2e,0x00a5,6,
NtMapUserPhysicalPages=0x2e,0x00a6,3,
NtMapUserPhysicalPagesScatter=0x2e,0x00a7,3,
NtMapViewOfSection=0x2e,0x00a8,10,
NtModifyBootEntry=0x2e,0x00a9,1,
NtModifyDriverEntry=0x2e,0x00aa,1,
NtNotifyChangeDirectoryFile=0x2e,0x00ab,9,
NtNotifyChangeKey=0x2e,0x00ac,10,
NtNotifyChangeMultipleKeys=0x2e,0x00ad,12,
NtNotifyChangeSession=0x2e,0x00ae,8,
NtOpenDirectoryObject=0x2e,0x00af,3,
NtOpenEnlistment=0x2e,0x00b0,5,
NtOpenEvent=0x2e,0x00b1,3,
NtOpenEventPair=0x2e,0x00b2,3,
NtOpenFile=0x2e,0x00b3,6,
NtOpenIoCompletion=0x2e,0x00b4,3,
NtOpenJobObject=0x2e,0x00b5,3,
NtOpenKey=0x2e,0x00b6,3,
NtOpenKeyEx=0x2e,0x00b7,4,
NtOpenKeyedEvent=0x2e,0x00b8,3,
NtOpenKeyTransacted=0x2e,0x00b9,4,
NtOpenKeyTransactedEx=0x2e,0x00ba,5,
NtOpenMutant=0x2e,0x00bb,3,
NtOpenObjectAuditAlarm=0x2e,0x00bc,12,
NtOpenPrivateNamespace=0x2e,0x00bd,4,
NtOpenProcess=0x2e,0x00be,4,
NtOpenProcessToken=0x2e,0x00bf,3,
NtOpenProcessTokenEx=0x2e,0x00c0,4,
NtOpenResourceManager=0x2e,0x00c1,5,
NtOpenSection=0x2e,0x00c2,3,
NtOpenSemaphore=0x2e,0x00c3,3,
NtOpenSession=0x2e,0x00c4,3,
NtOpenSymbolicLinkObject=0x2e,0x00c5,3,
NtOpenThread=0x2e,0x00c6,4,
NtOpenThreadToken=0x2e,0x00c7,4,
NtOpenThreadTokenEx=0x2e,0x00c8,5,
NtOpenTimer=0x2e,0x00c9,3,
NtOpenTransaction=0x2e,0x00ca,5,
NtOpenTransactionManager=0x2e,0x00cb,6,
NtPlugPlayControl=0x2e,0x00cc,3,
NtPowerInformation=0x2e,0x00cd,5,
NtPrepareComplete=0x2e,0x00ce,2,
NtPrepareEnlistment=0x2e,0x00cf,2,
NtPrePrepareComplete=0x2e,0x00d0,2,
NtPrePrepareEnlistment=0x2e,0x00d1,2,
NtPrivilegeCheck=0x2e,0x00d2,3,
NtPrivilegedServiceAuditAlarm=0x2e,0x00d3,5,
NtPrivilegeObjectAuditAlarm=0x2e,0x00d4,6,
NtPropagationComplete=0x2e,0x00d5,4,
NtPropagationFailed=0x2e,0x00d6,3,
NtProtectVirtualMemory=0x2e,0x00d7,5,
NtPulseEvent=0x2e,0x00d8,2,
NtQueryAttributesFile=0x2e,0x00d9,2,
NtQueryBootEntryOrder=0x2e,0x00da,2,
NtQueryBootOptions=0x2e,0x00db,2,
NtQueryDebugFilterState=0x2e,0x00dc,2,
NtQueryDefaultLocale=0x2e,0x00dd,2,
NtQueryDefaultUILanguage=0x2e,0x00de,1,
NtQueryDirectoryFile=0x2e,0x00df,11,
NtQueryDirectoryObject=0x2e,0x00e0,7,
NtQueryDriverEntryOrder=0x2e,0x00e1,2,
NtQueryEaFile=0x2e,0x00e2,9,
NtQueryEvent=0x2e,0x00e3,5,
NtQueryFullAttributesFile=0x2e,0x00e4,2,
NtQueryInformationAtom=0x2e,0x00e5,5,
NtQueryInformationEnlistment=0x2e,0x00e6,5,
NtQueryInformationFile=0x2e,0x00e7,5,
NtQueryInformationJobObject=0x2e,0x00e8,5,
NtQueryInformationPort=0x2e,0x00e9,5,
NtQueryInformationProcess=0x2e,0x00ea,5,
NtQueryInformationResourceManager=0x2e,0x00eb,5,
NtQueryInformationThread=0x2e,0x00ec,5,
NtQueryInformationToken=0x2e,0x00ed,5,
NtQueryInformationTransaction=0x2e,0x00ee,5,
NtQueryInformationTransactionManager=0x2e,0x00ef,5,
NtQueryInformationWorkerFactory=0x2e,0x00f0,5,
NtQueryInstallUILanguage=0x2e,0x00f1,1,
NtQueryIntervalProfile=0x2e,0x00f2,2,
NtQueryIoCompletion=0x2e,0x00f3,5,
NtQueryKey=0x2e,0x00f4,5,
NtQueryLicenseValue=0x2e,0x00f5,5,
NtQueryMultipleValueKey=0x2e,0x00f6,6,
NtQueryMutant=0x2e,0x00f7,5,
NtQueryObject=0x2e,0x00f8,5,
NtQueryOpenSubKeys=0x2e,0x00f9,2,
NtQueryOpenSubKeysEx=0x2e,0x00fa,4,
NtQueryPerformanceCounter=0x2e,0x00fb,2,
NtQueryPortInformationProcess=0x2e,0x00fc,0,
NtQueryQuotaInformationFile=0x2e,0x00fd,9,
NtQuerySection=0x2e,0x00fe,5,
NtQuerySecurityAttributesToken=0x2e,0x00ff,6,
NtQuerySecurityObject=0x2e,0x0100,5,
NtQuerySemaphore=0x2e,0x0101,5,
NtQuerySymbolicLinkObject=0x2e,0x0102,3,
NtQuerySystemEnvironmentValue=0x2e,0x0103,4,
NtQuerySystemEnvironmentValueEx=0x2e,0x0104,5,
NtQuerySystemInformation=0x2e,0x0105,4,
NtQuerySystemInformationEx=0x2e,0x0106,6,
NtQuerySystemTime=0x2e,0x0107,1,
NtQueryTimer=0x2e,0x0108,5,
NtQueryTimerResolution=0x2e,0x0109,3,
NtQueryValueKey=0x2e,0x010a,6,
NtQueryVirtualMemory=0x2e,0x010b,6,
NtQueryVolumeInformationFile=0x2e,0x010c,5,
NtQueueApcThread=0x2e,0x010d,5,
NtQueueApcThreadEx=0x2e,0x010e,6,
NtRaiseException=0x2e,0x010f,3,
NtRaiseHardError=0x2e,0x0110,6,
NtReadFile=0x2e,0x0111,9,
NtReadFileScatter=0x2e,0x0112,9,
NtReadOnlyEnlistment=0x2e,0x0113,2,
NtReadRequestData=0x2e,0x0114,6,
NtReadVirtualMemory=0x2e,0x0115,5,
NtRecoverEnlistment=0x2e,0x0116,2,
NtRecoverResourceManager=0x2e,0x0117,1,
NtRecoverTransactionManager=0x2e,0x0118,1,
NtRegisterProtocolAddressInformation=0x2e,0x0119,5,
NtRegisterThreadTerminatePort=0x2e,0x011a,1,
NtReleaseKeyedEvent=0x2e,0x011b,4,
NtReleaseMutant=0x2e,0x011c,2,
NtReleaseSemaphore=0x2e,0x011d,3,
NtReleaseWorkerFactoryWorker=0x2e,0x011e,1,
NtRemoveIoCompletion=0x2e,0x011f,5,
NtRemoveIoCompletionEx=0x2e,0x0120,6,
NtRemoveProcessDebug=0x2e,0x0121,2,
NtRenameKey=0x2e,0x0122,2,
NtRenameTransactionManager=0x2e,0x0123,2,
NtReplaceKey=0x2e,0x0124,3,
NtReplacePartitionUnit=0x2e,0x0125,3,
NtReplyPort=0x2e,0x0126,2,
NtReplyWaitReceivePort=0x2e,0x0127,4,
NtReplyWaitReceivePortEx=0x2e,0x0128,5,
NtReplyWaitReplyPort=0x2e,0x0129,2,
NtRequestPort=0x2e,0x012a,2,
NtRequestWaitReplyPort=0x2e,0x012b,3,
NtResetEvent=0x2e,0x012c,2,
NtResetWriteWatch=0x2e,0x012d,3,
NtRestoreKey=0x2e,0x012e,3,
NtResumeProcess=0x2e,0x012f,1,
NtResumeThread=0x2e,0x0130,2,
NtRollbackComplete=0x2e,0x0131,2,
NtRollbackEnlistment=0x2e,0x0132,2,
NtRollbackTransaction=0x2e,0x0133,2,
NtRollforwardTransactionManager=0x2e,0x0134,2,
NtSaveKey=0x2e,0x0135,2,
NtSaveKeyEx=0x2e,0x0136,3,
NtSaveMergedKeys=0x2e,0x0137,3,
NtSecureConnectPort=0x2e,0x0138,9,
NtSerializeBoot=0x2e,0x0139,0,
NtSetBootEntryOrder=0x2e,0x013a,2,
NtSetBootOptions=0x2e,0x013b,2,
NtSetContextThread=0x2e,0x013c,2,
NtSetDebugFilterState=0x2e,0x013d,3,
NtSetDefaultHardErrorPort=0x2e,0x013e,1,
NtSetDefaultLocale=0x2e,0x013f,2,
NtSetDefaultUILanguage=0x2e,0x0140,1,
NtSetDriverEntryOrder=0x2e,0x0141,2,
NtSetEaFile=0x2e,0x0142,4,
NtSetEvent=0x2e,0x0143,2,
NtSetEventBoostPriority=0x2e,0x0144,1,
NtSetHighEventPair=0x2e,0x0145,1,
NtSetHighWaitLowEventPair=0x2e,0x0146,1,
NtSetInformationDebugObject=0x2e,0x0147,5,
NtSetInformationEnlistment=0x2e,0x0148,4,
NtSetInformationFile=0x2e,0x0149,5,
NtSetInformationJobObject=0x2e,0x014a,4,
NtSetInformationKey=0x2e,0x014b,4,
NtSetInformationObject=0x2e,0x014c,4,
NtSetInformationProcess=0x2e,0x014d,4,
NtSetInformationResourceManager=0x2e,0x014e,4,
NtSetInformationThread=0x2e,0x014f,4,
NtSetInformationToken=0x2e,0x0150,4,
NtSetInformationTransaction=0x2e,0x0151,4,
NtSetInformationTransactionManager=0x2e,0x0152,4,
NtSetInformationWorkerFactory=0x2e,0x0153,4,
NtSetIntervalProfile=0x2e,0x0154,2,
NtSetIoCompletion=0x2e,0x0155,5,
NtSetIoCompletionEx=0x2e,0x0156,6,
NtSetLdtEntries=0x2e,0x0157,6,
NtSetLowEventPair=0x2e,0x0158,1,
NtSetLowWaitHighEventPair=0x2e,0x0159,1,
NtSetQuotaInformationFile=0x2e,0x015a,4,
NtSetSecurityObject=0x2e,0x015b,3,
NtSetSystemEnvironmentValue=0x2e,0x015c,2,
NtSetSystemEnvironmentValueEx=0x2e,0x015d,5,
NtSetSystemInformation=0x2e,0x015e,3,
NtSetSystemPowerState=0x2e,0x015f,3,
NtSetSystemTime=0x2e,0x0160,2,
NtSetThreadExecutionState=0x2e,0x0161,2,
NtSetTimer=0x2e,0x0162,7,
NtSetTimerEx=0x2e,0x0163,4,
NtSetTimerResolution=0x2e,0x0164,3,
NtSetUuidSeed=0x2e,0x0165,1,
NtSetValueKey=0x2e,0x0166,6,
NtSetVolumeInformationFile=0x2e,0x0167,5,
NtShutdownSystem=0x2e,0x0168,1,
NtShutdownWorkerFactory=0x2e,0x0169,2,
NtSignalAndWaitForSingleObject=0x2e,0x016a,4,
NtSinglePhaseReject=0x2e,0x016b,2,
NtStartProfile=0x2e,0x016c,1,
NtStopProfile=0x2e,0x016d,1,
NtSuspendProcess=0x2e,0x016e,1,
NtSuspendThread=0x2e,0x016f,2,
NtSystemDebugControl=0x2e,0x0170,6,
NtTerminateJobObject=0x2e,0x0171,2,
NtTerminateProcess=0x2e,0x0172,2,
NtTerminateThread=0x2e,0x0173,2,
NtTestAlert=0x2e,0x0174,0,
NtThawRegistry=0x2e,0x0175,0,
NtThawTransactions=0x2e,0x0176,0,
NtTraceControl=0x2e,0x0177,6,
NtTraceEvent=0x2e,0x0178,4,
NtTranslateFilePath=0x2e,0x0179,4,
NtUmsThreadYield=0x2e,0x017a,1,
NtUnloadDriver=0x2e,0x017b,1,
NtUnloadKey=0x2e,0x017c,1,
NtUnloadKey2=0x2e,0x017d,2,
NtUnloadKeyEx=0x2e,0x017e,2,
NtUnlockFile=0x2e,0x017f,5,
NtUnlockVirtualMemory=0x2e,0x0180,4,
NtUnmapViewOfSection=0x2e,0x0181,2,
NtVdmControl=0x2e,0x0182,2,
NtWaitForDebugEvent=0x2e,0x0183,4,
NtWaitForKeyedEvent=0x2e,0x0184,4,
NtWaitForMultipleObjects=0x2e,0x0185,5,
NtWaitForMultipleObjects32=0x2e,0x0186,5,
NtWaitForSingleObject=0x2e,0x0187,3,
NtWaitForWorkViaWorkerFactory=0x2e,0x0188,2,
NtWaitHighEventPair=0x2e,0x0189,1,
NtWaitLowEventPair=0x2e,0x018a,1,
NtWorkerFactoryWorkerReady=0x2e,0x018b,1,
NtWriteFile=0x2e,0x018c,9,
NtWriteFileGather=0x2e,0x018d,9,
NtWriteRequestData=0x2e,0x018e,6,
NtWriteVirtualMemory=0x2e,0x018f,5,
NtYieldExecution=0x2e,0x0190,0,
NtGdiAbortDoc=0x2e,0x1000,1,
NtGdiAbortPath=0x2e,0x1001,1,
NtGdiAddFontResourceW=0x2e,0x1002,6,
NtGdiAddRemoteFontToDC=0x2e,0x1003,4,
NtGdiAddFontMemResourceEx=0x2e,0x1004,5,
NtGdiRemoveMergeFont=0x2e,0x1005,2,
NtGdiAddRemoteMMInstanceToDC=0x2e,0x1006,3,
NtGdiAlphaBlend=0x2e,0x1007,12,
NtGdiAngleArc=0x2e,0x1008,6,
NtGdiAnyLinkedFonts=0x2e,0x1009,0,
NtGdiFontIsLinked=0x2e,0x100a,1,
NtGdiArcInternal=0x2e,0x100b,10,
NtGdiBeginGdiRendering=0x2e,0x100c,2,
NtGdiBeginPath=0x2e,0x100d,1,
NtGdiBitBlt=0x2e,0x100e,11,
NtGdiCancelDC=0x2e,0x100f,1,
NtGdiCheckBitmapBits=0x2e,0x1010,8,
NtGdiCloseFigure=0x2e,0x1011,1,
NtGdiClearBitmapAttributes=0x2e,0x1012,2,
NtGdiClearBrushAttributes=0x2e,0x1013,2,
NtGdiColorCorrectPalette=0x2e,0x1014,6,
NtGdiCombineRgn=0x2e,0x1015,4,
NtGdiCombineTransform=0x2e,0x1016,3,
NtGdiComputeXformCoefficients=0x2e,0x1017,1,
NtGdiConfigureOPMProtectedOutput=0x2e,0x1018,4,
NtGdiConvertMetafileRect=0x2e,0x1019,2,
NtGdiCreateBitmap=0x2e,0x101a,5,
NtGdiCreateBitmapFromDxSurface=0x2e,0x101b,5,
NtGdiCreateClientObj=0x2e,0x101c,1,
NtGdiCreateColorSpace=0x2e,0x101d,1,
NtGdiCreateColorTransform=0x2e,0x101e,8,
NtGdiCreateCompatibleBitmap=0x2e,0x101f,3,
NtGdiCreateCompatibleDC=0x2e,0x1020,1,
NtGdiCreateDIBBrush=0x2e,0x1021,6,
NtGdiCreateDIBitmapInternal=0x2e,0x1022,11,
NtGdiCreateDIBSection=0x2e,0x1023,9,
NtGdiCreateEllipticRgn=0x2e,0x1024,4,
NtGdiCreateHalftonePalette=0x2e,0x1025,1,
NtGdiCreateHatchBrushInternal=0x2e,0x1026,3,
NtGdiCreateMetafileDC=0x2e,0x1027,1,
NtGdiCreateOPMProtectedOutputs=0x2e,0x1028,5,
NtGdiCreatePaletteInternal=0x2e,0x1029,2,
NtGdiCreatePatternBrushInternal=0x2e,0x102a,3,
NtGdiCreatePen=0x2e,0x102b,4,
NtGdiCreateRectRgn=0x2e,0x102c,4,
NtGdiCreateRoundRectRgn=0x2e,0x102d,6,
NtGdiCreateServerMetaFile=0x2e,0x102e,6,
NtGdiCreateSolidBrush=0x2e,0x102f,2,
NtGdiD3dContextCreate=0x2e,0x1030,4,
NtGdiD3dContextDestroy=0x2e,0x1031,1,
NtGdiD3dContextDestroyAll=0x2e,0x1032,1,
NtGdiD3dValidateTextureStageState=0x2e,0x1033,1,
NtGdiD3dDrawPrimitives2=0x2e,0x1034,7,
NtGdiDdGetDriverState=0x2e,0x1035,1,
NtGdiDdAddAttachedSurface=0x2e,0x1036,3,
NtGdiDdAlphaBlt=0x2e,0x1037,3,
NtGdiDdAttachSurface=0x2e,0x1038,2,
NtGdiDdBeginMoCompFrame=0x2e,0x1039,2,
NtGdiDdBlt=0x2e,0x103a,3,
NtGdiDdCanCreateSurface=0x2e,0x103b,2,
NtGdiDdCanCreateD3DBuffer=0x2e,0x103c,2,
NtGdiDdColorControl=0x2e,0x103d,2,
NtGdiDdCreateDirectDrawObject=0x2e,0x103e,1,
NtGdiDdCreateSurface=0x2e,0x103f,8,
NtGdiDdCreateD3DBuffer=0x2e,0x1040,8,
NtGdiDdCreateMoComp=0x2e,0x1041,2,
NtGdiDdCreateSurfaceObject=0x2e,0x1042,6,
NtGdiDdDeleteDirectDrawObject=0x2e,0x1043,1,
NtGdiDdDeleteSurfaceObject=0x2e,0x1044,1,
NtGdiDdDestroyMoComp=0x2e,0x1045,2,
NtGdiDdDestroySurface=0x2e,0x1046,2,
NtGdiDdDestroyD3DBuffer=0x2e,0x1047,1,
NtGdiDdEndMoCompFrame=0x2e,0x1048,2,
NtGdiDdFlip=0x2e,0x1049,5,
NtGdiDdFlipToGDISurface=0x2e,0x104a,2,
NtGdiDdGetAvailDriverMemory=0x2e,0x104b,2,
NtGdiDdGetBltStatus=0x2e,0x104c,2,
NtGdiDdGetDC=0x2e,0x104d,2,
NtGdiDdGetDriverInfo=0x2e,0x104e,2,
NtGdiDdGetDxPlugin=0x2e,0x104f,3,
NtGdiDdGetFlipStatus=0x2e,0x1050,2,
NtGdiDdGetInternalMoCompInfo=0x2e,0x1051,2,
NtGdiDdGetMoCompBuffInfo=0x2e,0x1052,2,
NtGdiDdGetMoCompGuids=0x2e,0x1053,2,
NtGdiDdGetMoCompFormats=0x2e,0x1054,2,
NtGdiDdGetScanLine=0x2e,0x1055,2,
NtGdiDdLock=0x2e,0x1056,3,
NtGdiDdLockD3D=0x2e,0x1057,2,
NtGdiDdQueryDirectDrawObject=0x2e,0x1058,11,
NtGdiDdQueryMoCompStatus=0x2e,0x1059,2,
NtGdiDdReenableDirectDrawObject=0x2e,0x105a,2,
NtGdiDdReleaseDC=0x2e,0x105b,1,
NtGdiDdRenderMoComp=0x2e,0x105c,2,
NtGdiDdResetVisrgn=0x2e,0x105d,2,
NtGdiDdSetColorKey=0x2e,0x105e,2,
NtGdiDdSetExclusiveMode=0x2e,0x105f,2,
NtGdiDdSetGammaRamp=0x2e,0x1060,3,
NtGdiDdCreateSurfaceEx=0x2e,0x1061,3,
NtGdiDdSetOverlayPosition=0x2e,0x1062,3,
NtGdiDdUnattachSurface=0x2e,0x1063,2,
NtGdiDdUnlock=0x2e,0x1064,2,
NtGdiDdUnlockD3D=0x2e,0x1065,2,
NtGdiDdUpdateOverlay=0x2e,0x1066,3,
NtGdiDdWaitForVerticalBlank=0x2e,0x1067,2,
NtGdiDvpCanCreateVideoPort=0x2e,0x1068,2,
NtGdiDvpColorControl=0x2e,0x1069,2,
NtGdiDvpCreateVideoPort=0x2e,0x106a,2,
NtGdiDvpDestroyVideoPort=0x2e,0x106b,2,
NtGdiDvpFlipVideoPort=0x2e,0x106c,4,
NtGdiDvpGetVideoPortBandwidth=0x2e,0x106d,2,
NtGdiDvpGetVideoPortField=0x2e,0x106e,2,
NtGdiDvpGetVideoPortFlipStatus=0x2e,0x106f,2,
NtGdiDvpGetVideoPortInputFormats=0x2e,0x1070,2,
NtGdiDvpGetVideoPortLine=0x2e,0x1071,2,
NtGdiDvpGetVideoPortOutputFormats=0x2e,0x1072,2,
NtGdiDvpGetVideoPortConnectInfo=0x2e,0x1073,2,
NtGdiDvpGetVideoSignalStatus=0x2e,0x1074,2,
NtGdiDvpUpdateVideoPort=0x2e,0x1075,4,
NtGdiDvpWaitForVideoPortSync=0x2e,0x1076,2,
NtGdiDvpAcquireNotification=0x2e,0x1077,3,
NtGdiDvpReleaseNotification=0x2e,0x1078,2,
NtGdiDxgGenericThunk=0x2e,0x1079,6,
NtGdiDeleteClientObj=0x2e,0x107a,1,
NtGdiDeleteColorSpace=0x2e,0x107b,1,
NtGdiDeleteColorTransform=0x2e,0x107c,2,
NtGdiDeleteObjectApp=0x2e,0x107d,1,
NtGdiDescribePixelFormat=0x2e,0x107e,4,
NtGdiDestroyOPMProtectedOutput=0x2e,0x107f,1,
NtGdiGetPerBandInfo=0x2e,0x1080,2,
NtGdiDoBanding=0x2e,0x1081,4,
NtGdiDoPalette=0x2e,0x1082,6,
NtGdiDrawEscape=0x2e,0x1083,4,
NtGdiEllipse=0x2e,0x1084,5,
NtGdiEnableEudc=0x2e,0x1085,1,
NtGdiEndDoc=0x2e,0x1086,1,
NtGdiEndGdiRendering=0x2e,0x1087,3,
NtGdiEndPage=0x2e,0x1088,1,
NtGdiEndPath=0x2e,0x1089,1,
NtGdiEnumFonts=0x2e,0x108a,8,
NtGdiEnumObjects=0x2e,0x108b,4,
NtGdiEqualRgn=0x2e,0x108c,2,
NtGdiEudcLoadUnloadLink=0x2e,0x108d,7,
NtGdiExcludeClipRect=0x2e,0x108e,5,
NtGdiExtCreatePen=0x2e,0x108f,11,
NtGdiExtCreateRegion=0x2e,0x1090,3,
NtGdiExtEscape=0x2e,0x1091,8,
NtGdiExtFloodFill=0x2e,0x1092,5,
NtGdiExtGetObjectW=0x2e,0x1093,3,
NtGdiExtSelectClipRgn=0x2e,0x1094,3,
NtGdiExtTextOutW=0x2e,0x1095,9,
NtGdiFillPath=0x2e,0x1096,1,
NtGdiFillRgn=0x2e,0x1097,3,
NtGdiFlattenPath=0x2e,0x1098,1,
NtGdiFlush=0x2e,0x1099,0,
NtGdiForceUFIMapping=0x2e,0x109a,2,
NtGdiFrameRgn=0x2e,0x109b,5,
NtGdiFullscreenControl=0x2e,0x109c,5,
NtGdiGetAndSetDCDword=0x2e,0x109d,4,
NtGdiGetAppClipBox=0x2e,0x109e,2,
NtGdiGetBitmapBits=0x2e,0x109f,3,
NtGdiGetBitmapDimension=0x2e,0x10a0,2,
NtGdiGetBoundsRect=0x2e,0x10a1,3,
NtGdiGetCertificate=0x2e,0x10a2,4,
NtGdiGetCertificateSize=0x2e,0x10a3,3,
NtGdiGetCharABCWidthsW=0x2e,0x10a4,6,
NtGdiGetCharacterPlacementW=0x2e,0x10a5,6,
NtGdiGetCharSet=0x2e,0x10a6,1,
NtGdiGetCharWidthW=0x2e,0x10a7,6,
NtGdiGetCharWidthInfo=0x2e,0x10a8,2,
NtGdiGetColorAdjustment=0x2e,0x10a9,2,
NtGdiGetColorSpaceforBitmap=0x2e,0x10aa,1,
NtGdiGetCOPPCompatibleOPMInformation=0x2e,0x10ab,3,
NtGdiGetDCDword=0x2e,0x10ac,3,
NtGdiGetDCforBitmap=0x2e,0x10ad,1,
NtGdiGetDCObject=0x2e,0x10ae,2,
NtGdiGetDCPoint=0x2e,0x10af,3,
NtGdiGetDeviceCaps=0x2e,0x10b0,2,
NtGdiGetDeviceGammaRamp=0x2e,0x10b1,2,
NtGdiGetDeviceCapsAll=0x2e,0x10b2,2,
NtGdiGetDIBitsInternal=0x2e,0x10b3,9,
NtGdiGetETM=0x2e,0x10b4,2,
NtGdiGetEudcTimeStampEx=0x2e,0x10b5,3,
NtGdiGetFontData=0x2e,0x10b6,5,
NtGdiGetFontFileData=0x2e,0x10b7,5,
NtGdiGetFontFileInfo=0x2e,0x10b8,5,
NtGdiGetFontResourceInfoInternalW=0x2e,0x10b9,7,
NtGdiGetGlyphIndicesW=0x2e,0x10ba,5,
NtGdiGetGlyphIndicesWInternal=0x2e,0x10bb,6,
NtGdiGetGlyphOutline=0x2e,0x10bc,8,
NtGdiGetOPMInformation=0x2e,0x10bd,3,
NtGdiGetKerningPairs=0x2e,0x10be,3,
NtGdiGetLinkedUFIs=0x2e,0x10bf,3,
NtGdiGetMiterLimit=0x2e,0x10c0,2,
NtGdiGetMonitorID=0x2e,0x10c1,3,
NtGdiGetNearestColor=0x2e,0x10c2,2,
NtGdiGetNearestPaletteIndex=0x2e,0x10c3,2,
NtGdiGetObjectBitmapPlugin=0x2e,0x10c4,2,
NtGdiGetOPMRandomNumber=0x2e,0x10c5,2,
NtGdiGetOutlineTextMetricsInternalW=0x2e,0x10c6,4,
NtGdiGetPath=0x2e,0x10c7,4,
NtGdiGetPixel=0x2e,0x10c8,3,
NtGdiGetRandomRgn=0x2e,0x10c9,3,
NtGdiGetRasterizerCaps=0x2e,0x10ca,2,
NtGdiGetRealizationInfo=0x2e,0x10cb,2,
NtGdiGetRegionData=0x2e,0x10cc,3,
NtGdiGetRgnBox=0x2e,0x10cd,2,
NtGdiGetServerMetaFileBits=0x2e,0x10ce,7,
DxgStubDvpUpdateVideoPort=0x2e,0x10cf,4,
NtGdiGetStats=0x2e,0x10d0,5,
NtGdiGetStockObject=0x2e,0x10d1,1,
NtGdiGetStringBitmapW=0x2e,0x10d2,5,
NtGdiGetSuggestedOPMProtectedOutputArraySize=0x2e,0x10d3,2,
NtGdiGetSystemPaletteUse=0x2e,0x10d4,1,
NtGdiGetTextCharsetInfo=0x2e,0x10d5,3,
NtGdiGetTextExtent=0x2e,0x10d6,5,
NtGdiGetTextExtentExW=0x2e,0x10d7,8,
NtGdiGetTextFaceW=0x2e,0x10d8,4,
NtGdiGetTextMetricsW=0x2e,0x10d9,3,
NtGdiGetTransform=0x2e,0x10da,3,
NtGdiGetUFI=0x2e,0x10db,6,
NtGdiGetEmbUFI=0x2e,0x10dc,7,
NtGdiGetUFIPathname=0x2e,0x10dd,10,
NtGdiGetEmbedFonts=0x2e,0x10de,0,
NtGdiChangeGhostFont=0x2e,0x10df,2,
NtGdiAddEmbFontToDC=0x2e,0x10e0,2,
NtGdiGetFontUnicodeRanges=0x2e,0x10e1,2,
NtGdiGetWidthTable=0x2e,0x10e2,7,
NtGdiGradientFill=0x2e,0x10e3,6,
NtGdiHfontCreate=0x2e,0x10e4,5,
NtGdiIcmBrushInfo=0x2e,0x10e5,8,
bInitRedirDev=0x2e,0x10e6,0,
NtGdiInitSpool=0x2e,0x10e7,0,
NtGdiIntersectClipRect=0x2e,0x10e8,5,
NtGdiInvertRgn=0x2e,0x10e9,2,
NtGdiLineTo=0x2e,0x10ea,3,
NtGdiMakeFontDir=0x2e,0x10eb,5,
NtGdiMakeInfoDC=0x2e,0x10ec,2,
NtGdiMaskBlt=0x2e,0x10ed,13,
NtGdiModifyWorldTransform=0x2e,0x10ee,3,
NtGdiMonoBitmap=0x2e,0x10ef,1,
NtGdiMoveTo=0x2e,0x10f0,4,
NtGdiOffsetClipRgn=0x2e,0x10f1,3,
NtGdiOffsetRgn=0x2e,0x10f2,3,
NtGdiOpenDCW=0x2e,0x10f3,8,
NtGdiPatBlt=0x2e,0x10f4,6,
NtGdiPolyPatBlt=0x2e,0x10f5,5,
NtGdiPathToRegion=0x2e,0x10f6,1,
NtGdiPlgBlt=0x2e,0x10f7,11,
NtGdiPolyDraw=0x2e,0x10f8,4,
NtGdiPolyPolyDraw=0x2e,0x10f9,5,
NtGdiPolyTextOutW=0x2e,0x10fa,4,
NtGdiPtInRegion=0x2e,0x10fb,3,
NtGdiPtVisible=0x2e,0x10fc,3,
NtGdiQueryFonts=0x2e,0x10fd,3,
NtGdiQueryFontAssocInfo=0x2e,0x10fe,1,
NtGdiRectangle=0x2e,0x10ff,5,
NtGdiRectInRegion=0x2e,0x1100,2,
NtGdiRectVisible=0x2e,0x1101,2,
NtGdiRemoveFontResourceW=0x2e,0x1102,6,
NtGdiRemoveFontMemResourceEx=0x2e,0x1103,1,
NtGdiResetDC=0x2e,0x1104,5,
NtGdiResizePalette=0x2e,0x1105,2,
NtGdiRestoreDC=0x2e,0x1106,2,
NtGdiRoundRect=0x2e,0x1107,7,
NtGdiSaveDC=0x2e,0x1108,1,
NtGdiScaleViewportExtEx=0x2e,0x1109,6,
NtGdiScaleWindowExtEx=0x2e,0x110a,6,
NtGdiSelectBitmap=0x2e,0x110b,2,
NtGdiSelectBrush=0x2e,0x110c,2,
NtGdiSelectClipPath=0x2e,0x110d,2,
NtGdiSelectFont=0x2e,0x110e,2,
NtGdiSelectPen=0x2e,0x110f,2,
NtGdiSetBitmapAttributes=0x2e,0x1110,2,
NtGdiSetBitmapBits=0x2e,0x1111,3,
NtGdiSetBitmapDimension=0x2e,0x1112,4,
NtGdiSetBoundsRect=0x2e,0x1113,3,
NtGdiSetBrushAttributes=0x2e,0x1114,2,
NtGdiSetBrushOrg=0x2e,0x1115,4,
NtGdiSetColorAdjustment=0x2e,0x1116,2,
NtGdiSetColorSpace=0x2e,0x1117,2,
NtGdiSetDeviceGammaRamp=0x2e,0x1118,2,
NtGdiSetDIBitsToDeviceInternal=0x2e,0x1119,16,
NtGdiSetFontEnumeration=0x2e,0x111a,1,
NtGdiSetFontXform=0x2e,0x111b,3,
NtGdiSetIcmMode=0x2e,0x111c,3,
NtGdiSetLinkedUFIs=0x2e,0x111d,3,
NtGdiSetMagicColors=0x2e,0x111e,3,
NtGdiSetMetaRgn=0x2e,0x111f,1,
NtGdiSetMiterLimit=0x2e,0x1120,3,
NtGdiGetDeviceWidth=0x2e,0x1121,1,
NtGdiMirrorWindowOrg=0x2e,0x1122,1,
NtGdiSetLayout=0x2e,0x1123,3,
NtGdiSetOPMSigningKeyAndSequenceNumbers=0x2e,0x1124,2,
NtGdiSetPixel=0x2e,0x1125,4,
NtGdiSetPixelFormat=0x2e,0x1126,2,
NtGdiSetRectRgn=0x2e,0x1127,5,
NtGdiSetSystemPaletteUse=0x2e,0x1128,2,
NtGdiSetTextJustification=0x2e,0x1129,3,
NtGdiSetVirtualResolution=0x2e,0x112a,5,
NtGdiSetSizeDevice=0x2e,0x112b,3,
NtGdiStartDoc=0x2e,0x112c,4,
NtGdiStartPage=0x2e,0x112d,1,
NtGdiStretchBlt=0x2e,0x112e,12,
NtGdiStretchDIBitsInternal=0x2e,0x112f,16,
NtGdiStrokeAndFillPath=0x2e,0x1130,1,
NtGdiStrokePath=0x2e,0x1131,1,
NtGdiSwapBuffers=0x2e,0x1132,1,
NtGdiTransformPoints=0x2e,0x1133,5,
NtGdiTransparentBlt=0x2e,0x1134,11,
DxgStubEndMoCompFrame=0x2e,0x1135,2,
NtGdiUMPDEngFreeUserMem=0x2e,0x1136,1,
NtGdiUnrealizeObject=0x2e,0x1137,1,
NtGdiUpdateColors=0x2e,0x1138,1,
NtGdiWidenPath=0x2e,0x1139,1,
NtUserActivateKeyboardLayout=0x2e,0x113a,2,
NtUserAddClipboardFormatListener=0x2e,0x113b,1,
NtUserAlterWindowStyle=0x2e,0x113c,3,
NtUserAssociateInputContext=0x2e,0x113d,3,
NtUserAttachThreadInput=0x2e,0x113e,3,
NtUserBeginPaint=0x2e,0x113f,2,
NtUserBitBltSysBmp=0x2e,0x1140,8,
NtUserBlockInput=0x2e,0x1141,1,
NtUserBuildHimcList=0x2e,0x1142,4,
NtUserBuildHwndList=0x2e,0x1143,7,
NtUserBuildNameList=0x2e,0x1144,4,
NtUserBuildPropList=0x2e,0x1145,4,
NtUserCallHwnd=0x2e,0x1146,2,
NtUserCallHwndLock=0x2e,0x1147,2,
NtUserCallHwndOpt=0x2e,0x1148,2,
NtUserCallHwndParam=0x2e,0x1149,3,
NtUserCallHwndParamLock=0x2e,0x114a,3,
NtUserCallMsgFilter=0x2e,0x114b,2,
NtUserCallNextHookEx=0x2e,0x114c,4,
NtUserCallNoParam=0x2e,0x114d,1,
NtUserCallOneParam=0x2e,0x114e,2,
NtUserCallTwoParam=0x2e,0x114f,3,
NtUserChangeClipboardChain=0x2e,0x1150,2,
NtUserChangeDisplaySettings=0x2e,0x1151,4,
NtUserGetDisplayConfigBufferSizes=0x2e,0x1152,3,
NtUserSetDisplayConfig=0x2e,0x1153,5,
NtUserQueryDisplayConfig=0x2e,0x1154,6,
NtUserDisplayConfigGetDeviceInfo=0x2e,0x1155,1,
NtUserDisplayConfigSetDeviceInfo=0x2e,0x1156,1,
NtUserCheckAccessForIntegrityLevel=0x2e,0x1157,3,
NtUserCheckDesktopByThreadId=0x2e,0x1158,1,
NtUserCheckWindowThreadDesktop=0x2e,0x1159,2,
NtUserCheckMenuItem=0x2e,0x115a,3,
NtUserChildWindowFromPointEx=0x2e,0x115b,4,
NtUserClipCursor=0x2e,0x115c,1,
NtUserCloseClipboard=0x2e,0x115d,0,
NtUserCloseDesktop=0x2e,0x115e,1,
NtUserCloseWindowStation=0x2e,0x115f,1,
NtUserConsoleControl=0x2e,0x1160,3,
NtUserConvertMemPlugin=0x2e,0x1161,2,
NtUserCopyAcceleratorTable=0x2e,0x1162,3,
NtUserCountClipboardFormats=0x2e,0x1163,0,
NtUserCreateAcceleratorTable=0x2e,0x1164,2,
NtUserCreateCaret=0x2e,0x1165,4,
NtUserCreateDesktopEx=0x2e,0x1166,6,
NtUserCreateInputContext=0x2e,0x1167,1,
NtUserCreateLocalMemPlugin=0x2e,0x1168,4,
NtUserCreateWindowEx=0x2e,0x1169,15,
NtUserCreateWindowStation=0x2e,0x116a,8,
NtUserDdeInitialize=0x2e,0x116b,5,
NtUserDeferWindowPos=0x2e,0x116c,8,
NtUserDefSetText=0x2e,0x116d,2,
NtUserDeleteMenu=0x2e,0x116e,3,
NtUserDestroyAcceleratorTable=0x2e,0x116f,1,
NtUserDestroyCursor=0x2e,0x1170,2,
NtUserDestroyInputContext=0x2e,0x1171,1,
NtUserDestroyMenu=0x2e,0x1172,1,
NtUserDestroyWindow=0x2e,0x1173,1,
NtUserDisableThreadIme=0x2e,0x1174,1,
NtUserDispatchMessage=0x2e,0x1175,1,
NtUserDoSoundConnect=0x2e,0x1176,0,
NtUserDoSoundDisconnect=0x2e,0x1177,0,
NtUserDragDetect=0x2e,0x1178,3,
NtUserDragObject=0x2e,0x1179,5,
NtUserDrawAnimatedRects=0x2e,0x117a,4,
NtUserDrawCaption=0x2e,0x117b,4,
NtUserDrawCaptionTemp=0x2e,0x117c,7,
NtUserDrawIconEx=0x2e,0x117d,11,
NtUserDrawMenuBarTemp=0x2e,0x117e,5,
NtUserEmptyClipboard=0x2e,0x117f,0,
NtUserEnableMenuItem=0x2e,0x1180,3,
NtUserEnableScrollBar=0x2e,0x1181,3,
NtUserEndDeferWindowPosEx=0x2e,0x1182,2,
NtUserEndMenu=0x2e,0x1183,0,
NtUserEndPaint=0x2e,0x1184,2,
NtUserEnumDisplayDevices=0x2e,0x1185,4,
NtUserEnumDisplayMonitors=0x2e,0x1186,4,
NtUserEnumDisplaySettings=0x2e,0x1187,4,
NtUserEvent=0x2e,0x1188,1,
NtUserExcludeUpdateRgn=0x2e,0x1189,2,
NtUserFillWindow=0x2e,0x118a,4,
NtUserFindExistingCursorIcon=0x2e,0x118b,3,
NtUserFindWindowEx=0x2e,0x118c,5,
NtUserFlashWindowEx=0x2e,0x118d,1,
NtUserFrostCrashedWindow=0x2e,0x118e,2,
NtUserGetAltTabInfo=0x2e,0x118f,6,
NtUserGetAncestor=0x2e,0x1190,2,
NtUserGetAppImeLevel=0x2e,0x1191,1,
NtUserGetAsyncKeyState=0x2e,0x1192,1,
NtUserGetAtomName=0x2e,0x1193,2,
NtUserGetCaretBlinkTime=0x2e,0x1194,0,
NtUserGetCaretPos=0x2e,0x1195,1,
NtUserGetClassInfoEx=0x2e,0x1196,5,
NtUserGetClassName=0x2e,0x1197,3,
NtUserGetClipboardData=0x2e,0x1198,2,
NtUserGetClipboardFormatName=0x2e,0x1199,3,
NtUserGetClipboardOwner=0x2e,0x119a,0,
NtUserGetClipboardSequenceNumber=0x2e,0x119b,0,
NtUserGetClipboardViewer=0x2e,0x119c,0,
NtUserGetClipCursor=0x2e,0x119d,1,
NtUserGetComboBoxInfo=0x2e,0x119e,2,
NtUserGetControlBrush=0x2e,0x119f,3,
NtUserGetControlColor=0x2e,0x11a0,4,
NtUserGetCPD=0x2e,0x11a1,3,
NtUserGetCursorFrameInfo=0x2e,0x11a2,4,
NtUserGetCursorInfo=0x2e,0x11a3,1,
NtUserGetDC=0x2e,0x11a4,1,
NtUserGetDCEx=0x2e,0x11a5,3,
NtUserGetDoubleClickTime=0x2e,0x11a6,0,
NtUserGetForegroundWindow=0x2e,0x11a7,0,
NtUserGetGuiResources=0x2e,0x11a8,2,
NtUserGetGUIThreadInfo=0x2e,0x11a9,2,
NtUserGetIconInfo=0x2e,0x11aa,6,
NtUserGetIconSize=0x2e,0x11ab,4,
NtUserGetImeHotKey=0x2e,0x11ac,4,
NtUserGetImeInfoEx=0x2e,0x11ad,2,
NtUserGetInputLocaleInfo=0x2e,0x11ae,2,
NtUserGetInternalWindowPos=0x2e,0x11af,3,
NtUserGetKeyboardLayoutList=0x2e,0x11b0,2,
NtUserGetKeyboardLayoutName=0x2e,0x11b1,1,
NtUserGetKeyboardState=0x2e,0x11b2,1,
NtUserGetKeyNameText=0x2e,0x11b3,3,
NtUserGetKeyState=0x2e,0x11b4,1,
NtUserGetListBoxInfo=0x2e,0x11b5,1,
NtUserGetMenuBarInfo=0x2e,0x11b6,4,
NtUserGetMenuIndex=0x2e,0x11b7,2,
NtUserGetMenuItemRect=0x2e,0x11b8,4,
NtUserGetMessage=0x2e,0x11b9,4,
NtUserGetMouseMovePointsEx=0x2e,0x11ba,5,
NtUserGetObjectInformation=0x2e,0x11bb,5,
NtUserGetOpenClipboardWindow=0x2e,0x11bc,0,
NtUserGetPriorityClipboardFormat=0x2e,0x11bd,2,
NtUserGetProcessWindowStation=0x2e,0x11be,0,
NtUserGetRawInputBuffer=0x2e,0x11bf,3,
NtUserGetRawInputData=0x2e,0x11c0,5,
NtUserGetRawInputDeviceInfo=0x2e,0x11c1,4,
NtUserGetRawInputDeviceList=0x2e,0x11c2,3,
NtUserGetRegisteredRawInputDevices=0x2e,0x11c3,3,
NtUserGetScrollBarInfo=0x2e,0x11c4,3,
NtUserGetSystemMenu=0x2e,0x11c5,2,
NtUserGetThreadDesktop=0x2e,0x11c6,1,
NtUserGetThreadState=0x2e,0x11c7,1,
NtUserGetTitleBarInfo=0x2e,0x11c8,2,
NtUserGetTopLevelWindow=0x2e,0x11c9,1,
NtUserGetUpdatedClipboardFormats=0x2e,0x11ca,3,
NtUserGetUpdateRect=0x2e,0x11cb,3,
NtUserGetUpdateRgn=0x2e,0x11cc,3,
NtUserGetWindowCompositionInfo=0x2e,0x11cd,2,
NtUserGetWindowCompositionAttribute=0x2e,0x11ce,2,
NtUserGetWindowDC=0x2e,0x11cf,1,
NtUserGetWindowDisplayAffinity=0x2e,0x11d0,2,
NtUserGetWindowPlacement=0x2e,0x11d1,2,
NtUserGetWOWClass=0x2e,0x11d2,2,
NtUserGhostWindowFromHungWindow=0x2e,0x11d3,1,
NtUserHardErrorControl=0x2e,0x11d4,3,
NtUserHideCaret=0x2e,0x11d5,1,
NtUserHiliteMenuItem=0x2e,0x11d6,4,
NtUserHungWindowFromGhostWindow=0x2e,0x11d7,1,
NtUserImpersonateDdeClientWindow=0x2e,0x11d8,2,
NtUserInitialize=0x2e,0x11d9,2,
NtUserInitializeClientPfnArrays=0x2e,0x11da,4,
NtUserInitTask=0x2e,0x11db,12,
NtUserInternalGetWindowText=0x2e,0x11dc,3,
NtUserInternalGetWindowIcon=0x2e,0x11dd,2,
NtUserInvalidateRect=0x2e,0x11de,3,
NtUserInvalidateRgn=0x2e,0x11df,3,
NtUserIsClipboardFormatAvailable=0x2e,0x11e0,1,
NtUserIsTopLevelWindow=0x2e,0x11e1,1,
NtUserKillTimer=0x2e,0x11e2,2,
NtUserLoadKeyboardLayoutEx=0x2e,0x11e3,8,
NtUserLockWindowStation=0x2e,0x11e4,1,
NtUserLockWindowUpdate=0x2e,0x11e5,1,
NtUserLockWorkStation=0x2e,0x11e6,0,
NtUserLogicalToPhysicalPoint=0x2e,0x11e7,2,
NtUserMapVirtualKeyEx=0x2e,0x11e8,4,
NtUserMenuItemFromPoint=0x2e,0x11e9,4,
NtUserMessageCall=0x2e,0x11ea,7,
NtUserMinMaximize=0x2e,0x11eb,3,
NtUserMNDragLeave=0x2e,0x11ec,0,
NtUserMNDragOver=0x2e,0x11ed,2,
NtUserModifyUserStartupInfoFlags=0x2e,0x11ee,2,
NtUserMoveWindow=0x2e,0x11ef,6,
NtUserNotifyIMEStatus=0x2e,0x11f0,3,
NtUserNotifyProcessCreate=0x2e,0x11f1,4,
NtUserNotifyWinEvent=0x2e,0x11f2,4,
NtUserOpenClipboard=0x2e,0x11f3,2,
NtUserOpenDesktop=0x2e,0x11f4,3,
NtUserOpenInputDesktop=0x2e,0x11f5,3,
NtUserOpenThreadDesktop=0x2e,0x11f6,4,
NtUserOpenWindowStation=0x2e,0x11f7,2,
NtUserPaintDesktop=0x2e,0x11f8,1,
NtUserPaintMonitor=0x2e,0x11f9,3,
NtUserPeekMessage=0x2e,0x11fa,5,
NtUserPhysicalToLogicalPoint=0x2e,0x11fb,2,
NtUserPostMessage=0x2e,0x11fc,4,
NtUserPostThreadMessage=0x2e,0x11fd,4,
NtUserPrintWindow=0x2e,0x11fe,3,
NtUserProcessConnect=0x2e,0x11ff,2,
NtUserQueryInformationThread=0x2e,0x1200,4,
NtUserQueryInputContext=0x2e,0x1201,2,
NtUserQuerySendMessage=0x2e,0x1202,1,
NtUserQueryWindow=0x2e,0x1203,2,
NtUserRealChildWindowFromPoint=0x2e,0x1204,3,
NtUserRealInternalGetMessage=0x2e,0x1205,6,
NtUserRealWaitMessageEx=0x2e,0x1206,2,
NtUserRedrawWindow=0x2e,0x1207,4,
NtUserRegisterClassExWOW=0x2e,0x1208,7,
NtUserRegisterErrorReportingDialog=0x2e,0x1209,2,
NtUserRegisterUserApiHook=0x2e,0x120a,4,
NtUserRegisterHotKey=0x2e,0x120b,4,
NtUserRegisterRawInputDevices=0x2e,0x120c,3,
NtUserRegisterServicesProcess=0x2e,0x120d,1,
NtUserRegisterTasklist=0x2e,0x120e,1,
NtUserRegisterWindowMessage=0x2e,0x120f,1,
NtUserRemoveClipboardFormatListener=0x2e,0x1210,1,
NtUserRemoveMenu=0x2e,0x1211,3,
NtUserRemoveProp=0x2e,0x1212,2,
NtUserResolveDesktopForWOW=0x2e,0x1213,1,
NtUserSBGetParms=0x2e,0x1214,4,
NtUserScrollDC=0x2e,0x1215,7,
NtUserScrollWindowEx=0x2e,0x1216,8,
NtUserSelectPalette=0x2e,0x1217,3,
NtUserSendInput=0x2e,0x1218,3,
NtUserSetActiveWindow=0x2e,0x1219,1,
NtUserSetAppImeLevel=0x2e,0x121a,2,
NtUserSetCapture=0x2e,0x121b,1,
NtUserSetChildWindowNoActivate=0x2e,0x121c,1,
NtUserSetClassLong=0x2e,0x121d,4,
NtUserSetClassWord=0x2e,0x121e,3,
NtUserSetClipboardData=0x2e,0x121f,3,
NtUserSetClipboardViewer=0x2e,0x1220,1,
NtUserSetCursor=0x2e,0x1221,1,
NtUserSetCursorContents=0x2e,0x1222,2,
NtUserSetCursorIconData=0x2e,0x1223,4,
NtUserSetFocus=0x2e,0x1224,1,
NtUserSetImeHotKey=0x2e,0x1225,5,
NtUserSetImeInfoEx=0x2e,0x1226,1,
NtUserSetImeOwnerWindow=0x2e,0x1227,2,
NtUserSetInformationThread=0x2e,0x1228,4,
NtUserSetInternalWindowPos=0x2e,0x1229,4,
NtUserSetKeyboardState=0x2e,0x122a,1,
NtUserSetMenu=0x2e,0x122b,3,
NtUserSetMenuContextHelpId=0x2e,0x122c,2,
NtUserSetMenuDefaultItem=0x2e,0x122d,3,
NtUserSetMenuFlagRtoL=0x2e,0x122e,1,
NtUserSetObjectInformation=0x2e,0x122f,4,
NtUserSetParent=0x2e,0x1230,2,
NtUserSetProcessWindowStation=0x2e,0x1231,1,
NtUserGetProp=0x2e,0x1232,2,
NtUserSetProp=0x2e,0x1233,3,
NtUserSetScrollInfo=0x2e,0x1234,4,
NtUserSetShellWindowEx=0x2e,0x1235,2,
NtUserSetSysColors=0x2e,0x1236,4,
NtUserSetSystemCursor=0x2e,0x1237,2,
NtUserSetSystemMenu=0x2e,0x1238,2,
NtUserSetSystemTimer=0x2e,0x1239,3,
NtUserSetThreadDesktop=0x2e,0x123a,1,
NtUserSetThreadLayoutPlugins=0x2e,0x123b,2,
NtUserSetThreadState=0x2e,0x123c,2,
NtUserSetTimer=0x2e,0x123d,4,
NtUserSetProcessDPIAware=0x2e,0x123e,0,
NtUserSetWindowCompositionAttribute=0x2e,0x123f,2,
NtUserSetWindowDisplayAffinity=0x2e,0x1240,2,
NtUserSetWindowFNID=0x2e,0x1241,2,
NtUserSetWindowLong=0x2e,0x1242,4,
NtUserSetWindowPlacement=0x2e,0x1243,2,
NtUserSetWindowPos=0x2e,0x1244,7,
NtUserSetWindowRgn=0x2e,0x1245,3,
NtUserGetWindowRgnEx=0x2e,0x1246,3,
NtUserSetWindowRgnEx=0x2e,0x1247,3,
NtUserSetWindowsHookAW=0x2e,0x1248,3,
NtUserSetWindowsHookEx=0x2e,0x1249,6,
NtUserSetWindowStationUser=0x2e,0x124a,4,
NtUserSetWindowWord=0x2e,0x124b,3,
NtUserSetWinEventHook=0x2e,0x124c,8,
NtUserShowCaret=0x2e,0x124d,1,
NtUserShowScrollBar=0x2e,0x124e,3,
NtUserShowWindow=0x2e,0x124f,2,
NtUserShowWindowAsync=0x2e,0x1250,2,
NtUserSoundSentry=0x2e,0x1251,0,
NtUserSwitchDesktop=0x2e,0x1252,2,
NtUserSystemParametersInfo=0x2e,0x1253,4,
NtUserTestForInteractiveUser=0x2e,0x1254,1,
NtUserThunkedMenuInfo=0x2e,0x1255,2,
NtUserThunkedMenuItemInfo=0x2e,0x1256,6,
NtUserToUnicodeEx=0x2e,0x1257,7,
NtUserTrackMouseEvent=0x2e,0x1258,1,
NtUserTrackPopupMenuEx=0x2e,0x1259,6,
NtUserCalculatePopupWindowPosition=0x2e,0x125a,5,
NtUserCalcMenuBar=0x2e,0x125b,5,
NtUserPaintMenuBar=0x2e,0x125c,6,
NtUserTranslateAccelerator=0x2e,0x125d,3,
NtUserTranslateMessage=0x2e,0x125e,2,
NtUserUnhookWindowsHookEx=0x2e,0x125f,1,
NtUserUnhookWinEvent=0x2e,0x1260,1,
NtUserUnloadKeyboardLayout=0x2e,0x1261,1,
NtUserUnlockWindowStation=0x2e,0x1262,1,
NtUserUnregisterClass=0x2e,0x1263,3,
NtUserUnregisterUserApiHook=0x2e,0x1264,0,
NtUserUnregisterHotKey=0x2e,0x1265,2,
NtUserUpdateInputContext=0x2e,0x1266,3,
NtUserUpdateInstance=0x2e,0x1267,3,
NtUserUpdateLayeredWindow=0x2e,0x1268,10,
NtUserGetLayeredWindowAttributes=0x2e,0x1269,4,
NtUserSetLayeredWindowAttributes=0x2e,0x126a,4,
NtUserUpdatePerUserSystemParameters=0x2e,0x126b,1,
NtUserUserPluginGrantAccess=0x2e,0x126c,3,
NtUserValidatePluginSecure=0x2e,0x126d,1,
NtUserValidateRect=0x2e,0x126e,2,
NtUserValidateTimerCallback=0x2e,0x126f,1,
NtUserVkKeyScanEx=0x2e,0x1270,3,
NtUserWaitForInputIdle=0x2e,0x1271,3,
NtUserWaitForMsgAndEvent=0x2e,0x1272,1,
NtUserWaitMessage=0x2e,0x1273,0,
NtUserWindowFromPhysicalPoint=0x2e,0x1274,2,
NtUserWindowFromPoint=0x2e,0x1275,2,
NtUserYieldTask=0x2e,0x1276,0,
NtUserRemoteConnect=0x2e,0x1277,3,
NtUserRemoteRedrawRectangle=0x2e,0x1278,4,
NtUserRemoteRedrawScreen=0x2e,0x1279,0,
NtUserRemoteStopScreenUpdates=0x2e,0x127a,0,
NtUserCtxDisplayIOCtl=0x2e,0x127b,3,
NtUserRegisterSessionPort=0x2e,0x127c,2,
NtUserUnregisterSessionPort=0x2e,0x127d,0,
NtUserUpdateWindowTransform=0x2e,0x127e,3,
NtUserDwmStartRedirection=0x2e,0x127f,1,
NtUserDwmStopRedirection=0x2e,0x1280,0,
NtUserGetWindowMinimizeRect=0x2e,0x1281,2,
NtUserSfmDxBindSwapChain=0x2e,0x1282,3,
NtUserSfmDxOpenSwapChain=0x2e,0x1283,4,
NtUserSfmDxReleaseSwapChain=0x2e,0x1284,2,
NtUserSfmDxSetSwapChainBindingStatus=0x2e,0x1285,2,
NtUserSfmDxQuerySwapChainBindingStatus=0x2e,0x1286,3,
NtUserSfmDxReportPendingBindingsToDwm=0x2e,0x1287,0,
NtUserSfmDxGetSwapChainStats=0x2e,0x1288,2,
NtUserSfmDxSetSwapChainStats=0x2e,0x1289,2,
NtUserSfmGetLogicalSurfaceBinding=0x2e,0x128a,4,
NtUserSfmDestroyLogicalSurfaceBinding=0x2e,0x128b,1,
NtUserModifyWindowTouchCapability=0x2e,0x128c,3,
NtUserIsTouchWindow=0x2e,0x128d,2,
NtUserSendTouchInput=0x2e,0x128e,4,
NtUserEndTouchOperation=0x2e,0x128f,1,
NtUserGetTouchInputInfo=0x2e,0x1290,4,
NtUserChangeWindowMessageFilterEx=0x2e,0x1291,4,
NtUserInjectGesture=0x2e,0x1292,5,
NtUserGetGestureInfo=0x2e,0x1293,2,
NtUserGetGestureExtArgs=0x2e,0x1294,3,
NtUserManageGesturePluginWindow=0x2e,0x1295,2,
NtUserSetGestureConfig=0x2e,0x1296,5,
NtUserGetGestureConfig=0x2e,0x1297,6,
NtGdiEngAssociateSurface=0x2e,0x1298,3,
NtGdiEngCreateBitmap=0x2e,0x1299,6,
NtGdiEngCreateDeviceSurface=0x2e,0x129a,4,
NtGdiEngCreateDeviceBitmap=0x2e,0x129b,4,
NtGdiEngCreatePalette=0x2e,0x129c,6,
NtGdiEngComputeGlyphSet=0x2e,0x129d,3,
NtGdiEngCopyBits=0x2e,0x129e,6,
NtGdiEngDeletePalette=0x2e,0x129f,1,
NtGdiEngDeleteSurface=0x2e,0x12a0,1,
NtGdiEngEraseSurface=0x2e,0x12a1,3,
NtGdiEngUnlockSurface=0x2e,0x12a2,1,
NtGdiEngLockSurface=0x2e,0x12a3,1,
NtGdiEngBitBlt=0x2e,0x12a4,11,
NtGdiEngStretchBlt=0x2e,0x12a5,11,
NtGdiEngPlgBlt=0x2e,0x12a6,11,
NtGdiEngMarkBandingSurface=0x2e,0x12a7,1,
NtGdiEngStrokePath=0x2e,0x12a8,8,
NtGdiEngFillPath=0x2e,0x12a9,7,
NtGdiEngStrokeAndFillPath=0x2e,0x12aa,10,
NtGdiEngPaint=0x2e,0x12ab,5,
NtGdiEngLineTo=0x2e,0x12ac,9,
NtGdiEngAlphaBlend=0x2e,0x12ad,7,
NtGdiEngGradientFill=0x2e,0x12ae,10,
NtGdiEngTransparentBlt=0x2e,0x12af,8,
NtGdiEngTextOut=0x2e,0x12b0,10,
NtGdiEngStretchBltROP=0x2e,0x12b1,13,
NtGdiXLATEOBJ_cGetPalette=0x2e,0x12b2,4,
NtGdiXLATEOBJ_iXlate=0x2e,0x12b3,2,
NtGdiXLATEOBJ_hGetColorTransform=0x2e,0x12b4,1,
NtGdiCLIPOBJ_bEnum=0x2e,0x12b5,3,
NtGdiCLIPOBJ_cEnumStart=0x2e,0x12b6,5,
NtGdiCLIPOBJ_ppoGetPath=0x2e,0x12b7,1,
NtGdiEngDeletePath=0x2e,0x12b8,1,
NtGdiEngCreateClip=0x2e,0x12b9,0,
NtGdiEngDeleteClip=0x2e,0x12ba,1,
NtGdiBRUSHOBJ_ulGetBrushColor=0x2e,0x12bb,1,
NtGdiBRUSHOBJ_pvAllocRbrush=0x2e,0x12bc,2,
NtGdiBRUSHOBJ_pvGetRbrush=0x2e,0x12bd,1,
NtGdiBRUSHOBJ_hGetColorTransform=0x2e,0x12be,1,
NtGdiXFORMOBJ_bApplyXform=0x2e,0x12bf,5,
NtGdiXFORMOBJ_iGetXform=0x2e,0x12c0,2,
NtGdiFONTOBJ_vGetInfo=0x2e,0x12c1,3,
NtGdiFONTOBJ_pxoGetXform=0x2e,0x12c2,1,
NtGdiFONTOBJ_cGetGlyphs=0x2e,0x12c3,5,
NtGdiFONTOBJ_pifi=0x2e,0x12c4,1,
NtGdiFONTOBJ_pfdg=0x2e,0x12c5,1,
NtGdiFONTOBJ_pQueryGlyphAttrs=0x2e,0x12c6,2,
NtGdiFONTOBJ_pvTrueTypeFontFile=0x2e,0x12c7,2,
NtGdiFONTOBJ_cGetAllGlyphPlugins=0x2e,0x12c8,2,
NtGdiSTROBJ_bEnum=0x2e,0x12c9,3,
NtGdiSTROBJ_bEnumPositionsOnly=0x2e,0x12ca,3,
NtGdiSTROBJ_bGetAdvanceWidths=0x2e,0x12cb,4,
NtGdiSTROBJ_vEnumStart=0x2e,0x12cc,1,
NtGdiSTROBJ_dwGetCodePage=0x2e,0x12cd,1,
NtGdiPATHOBJ_vGetBounds=0x2e,0x12ce,2,
NtGdiPATHOBJ_bEnum=0x2e,0x12cf,2,
NtGdiPATHOBJ_vEnumStart=0x2e,0x12d0,1,
NtGdiPATHOBJ_vEnumStartClipLines=0x2e,0x12d1,4,
NtGdiPATHOBJ_bEnumClipLines=0x2e,0x12d2,3,
NtGdiGetDhpdev=0x2e,0x12d3,1,
NtGdiEngCheckAbort=0x2e,0x12d4,1,
NtGdiHT_Get8BPPFormatPalette=0x2e,0x12d5,4,
NtGdiHT_Get8BPPMaskPalette=0x2e,0x12d6,6,
NtGdiUpdateTransform=0x2e,0x12d7,1,
NtGdiSetPUMPDOBJ=0x2e,0x12d8,4,
NtGdiBRUSHOBJ_DeleteRbrush=0x2e,0x12d9,2,
NtGdiUMPDEngFreeUserMem=0x2e,0x12da,1,
NtGdiDrawStream=0x2e,0x12db,3,
NtGdiSfmGetNotificationTokens=0x2e,0x12dc,3,
NtGdiHLSurfGetInformation=0x2e,0x12dd,4,
NtGdiHLSurfSetInformation=0x2e,0x12de,4,
NtGdiDdDDICreateAllocation=0x2e,0x12df,1,
NtGdiDdDDIQueryResourceInfo=0x2e,0x12e0,1,
NtGdiDdDDIOpenResource=0x2e,0x12e1,1,
NtGdiDdDDIDestroyAllocation=0x2e,0x12e2,1,
NtGdiDdDDISetAllocationPriority=0x2e,0x12e3,1,
NtGdiDdDDIQueryAllocationResidency=0x2e,0x12e4,1,
NtGdiDdDDICreateDevice=0x2e,0x12e5,1,
NtGdiDdDDIDestroyDevice=0x2e,0x12e6,1,
NtGdiDdDDICreateContext=0x2e,0x12e7,1,
NtGdiDdDDIDestroyContext=0x2e,0x12e8,1,
NtGdiDdDDICreateSynchronizationObject=0x2e,0x12e9,1,
NtGdiDdDDIOpenSynchronizationObject=0x2e,0x12ea,1,
NtGdiDdDDIDestroySynchronizationObject=0x2e,0x12eb,1,
NtGdiDdDDIWaitForSynchronizationObject=0x2e,0x12ec,1,
NtGdiDdDDISignalSynchronizationObject=0x2e,0x12ed,1,
NtGdiDdDDIGetRuntimeData=0x2e,0x12ee,1,
NtGdiDdDDIQueryAdapterInfo=0x2e,0x12ef,1,
NtGdiDdDDILock=0x2e,0x12f0,1,
NtGdiDdDDIUnlock=0x2e,0x12f1,1,
NtGdiDdDDIGetDisplayModeList=0x2e,0x12f2,1,
NtGdiDdDDISetDisplayMode=0x2e,0x12f3,1,
NtGdiDdDDIGetMultisampleMethodList=0x2e,0x12f4,1,
NtGdiDdDDIPresent=0x2e,0x12f5,1,
NtGdiDdDDIRender=0x2e,0x12f6,1,
NtGdiDdDDIOpenAdapterFromDeviceName=0x2e,0x12f7,1,
NtGdiDdDDIOpenAdapterFromHdc=0x2e,0x12f8,1,
NtGdiDdDDICloseAdapter=0x2e,0x12f9,1,
NtGdiDdDDIGetSharedPrimaryPlugin=0x2e,0x12fa,1,
NtGdiDdDDIEscape=0x2e,0x12fb,1,
NtGdiDdDDIQueryStatistics=0x2e,0x12fc,1,
NtGdiDdDDISetVidPnSourceOwner=0x2e,0x12fd,1,
NtGdiDdDDIGetPresentHistory=0x2e,0x12fe,1,
NtGdiDdDDIGetPresentQueueEvent=0x2e,0x12ff,2,
NtGdiDdDDICreateOverlay=0x2e,0x1300,1,
NtGdiDdDDIUpdateOverlay=0x2e,0x1301,1,
NtGdiDdDDIFlipOverlay=0x2e,0x1302,1,
NtGdiDdDDIDestroyOverlay=0x2e,0x1303,1,
NtGdiDdDDIWaitForVerticalBlankEvent=0x2e,0x1304,1,
NtGdiDdDDISetGammaRamp=0x2e,0x1305,1,
NtGdiDdDDIGetDeviceState=0x2e,0x1306,1,
NtGdiDdDDICreateDCFromMemory=0x2e,0x1307,1,
NtGdiDdDDIDestroyDCFromMemory=0x2e,0x1308,1,
NtGdiDdDDISetContextSchedulingPriority=0x2e,0x1309,1,
NtGdiDdDDIGetContextSchedulingPriority=0x2e,0x130a,1,
NtGdiDdDDISetProcessSchedulingPriorityClass=0x2e,0x130b,2,
NtGdiDdDDIGetProcessSchedulingPriorityClass=0x2e,0x130c,2,
NtGdiDdDDIReleaseProcessVidPnSourceOwners=0x2e,0x130d,1,
NtGdiDdDDIGetScanLine=0x2e,0x130e,1,
NtGdiDdDDISetQueuedLimit=0x2e,0x130f,1,
NtGdiDdDDIPollDisplayChildren=0x2e,0x1310,1,
NtGdiDdDDIInvalidateActiveVidPn=0x2e,0x1311,1,
NtGdiDdDDICheckOcclusion=0x2e,0x1312,1,
NtGdiDdDDIWaitForIdle=0x2e,0x1313,1,
NtGdiDdDDICheckMonitorPowerState=0x2e,0x1314,1,
NtGdiDdDDICheckExclusiveOwnership=0x2e,0x1315,0,
NtGdiDdDDISetDisplayPrivateDriverFormat=0x2e,0x1316,1,
NtGdiDdDDISharedPrimaryLockNotification=0x2e,0x1317,1,
NtGdiDdDDISharedPrimaryUnLockNotification=0x2e,0x1318,1,
NtGdiDdDDICreateKeyedMutex=0x2e,0x1319,1,
NtGdiDdDDIOpenKeyedMutex=0x2e,0x131a,1,
NtGdiDdDDIDestroyKeyedMutex=0x2e,0x131b,1,
NtGdiDdDDIAcquireKeyedMutex=0x2e,0x131c,1,
NtGdiDdDDIReleaseKeyedMutex=0x2e,0x131d,1,
NtGdiDdDDIConfigureSharedResource=0x2e,0x131e,1,
NtGdiDdDDIGetOverlayState=0x2e,0x131f,1,
NtGdiDdDDICheckVidPnExclusiveOwnership=0x2e,0x1320,1,
NtGdiDdDDICheckSharedResourceAccess=0x2e,0x1321,1,
DxgStubEndMoCompFrame=0x2e,0x1322,2,
DxgStubContextDestroyAll=0x2e,0x1323,1,
NtGdiGetNumberOfPhysicalMonitors=0x2e,0x1324,2,
NtGdiGetPhysicalMonitors=0x2e,0x1325,4,
NtGdiGetPhysicalMonitorDescription=0x2e,0x1326,3,
NtGdiDestroyPhysicalMonitor=0x2e,0x1327,1,
NtGdiDDCCIGetVCPFeature=0x2e,0x1328,5,
NtGdiDDCCISetVCPFeature=0x2e,0x1329,3,
NtGdiDDCCISaveCurrentSettings=0x2e,0x132a,1,
NtGdiDDCCIGetCapabilitiesStringLength=0x2e,0x132b,2,
NtGdiDDCCIGetCapabilitiesString=0x2e,0x132c,3,
NtGdiDDCCIGetTimingReport=0x2e,0x132d,2,
NtGdiDdCreateFullscreenSprite=0x2e,0x132e,4,
NtGdiDdNotifyFullscreenSpriteUpdate=0x2e,0x132f,2,
NtGdiDdDestroyFullscreenSprite=0x2e,0x1330,2,
DxEngVisRgnUniq=0x2e,0x1331,0,
NtUserSetMirrorRendering=0x2e,0x1332,2,
NtUserShowSystemCursor=0x2e,0x1333,1,
NtUserMagControl=0x2e,0x1334,2,
NtUserMagSetContextInformation=0x2e,0x1335,4,
NtUserMagGetContextInformation=0x2e,0x1336,4,
NtUserHwndQueryRedirectionInfo=0x2e,0x1337,4,
NtUserHwndSetRedirectionInfo=0x2e,0x1338,4,
rizin-0.7.4/librz/syscall/d/linux-mips-32.sdb.txt 0000664 0001750 0001750 00000002016 14731035230 021072 0 ustar sophie sophie _=4000
syscall=0xfa0,4000,1,i
exit=0xfa0,4001,1,i
fork=0xfa0,4002,0,
read=0xfa0,4003,3,ipi
write=0xfa0,4004,3,izi
open=0xfa0,4005,3,zxx
close=0xfa0,4006,1,i
waitpid=0xfa0,4007,3,ipx
creat=0xfa0,4008,2,zx
link=0xfa0,4009,2,zz
unlink=0xfa0,4010,1,z
execve=0xfa0,4011,3,zzz
chdir=0xfa0,4012,1,z
time=0xfa0,4013,1,p
mknod=0xfa0,4014,1,zxi
chmod=0xfa0,4015,1,zx
lchown=0xfa0,4016,1,zii
getpid=0xfa0,4020,0,
setuid=0xfa0,4023,1,i
getuid=0xfa0,4024,0,
ptrace=0xfa0,4026,4,
utime=0xfa0,4030,2,
access=0xfa0,4033,2,
kill=0xfa0,4037,2,
dup=0xfa0,4041,2,
brk=0xfa0,4045,1,
signal=0xfa0,4048,2,
ioctl=0xfa0,4054,3,
mmap=0xfa0,4090,6,
munmap=0xfa0,4091,1,
socketcall=0xfa0+102,4102,2,
sigreturn=0xfa0+119,4119,1,
clone=0xfa0+120,4120,4,
mprotect=0xfa0+125,4125,3,
rt_sigaction=0xfa0+174,4174,3,
rt_sigprocmask=0xfa0+175,4175,3,
sysctl=0xfa0+149,4149,1,
mmap2=0xfa0+192,4192,6,
fstat64=0xfa0+197,4197,2,
fcntl64=0xfa0+221,4221,3,
gettid=0xfa0+224,4224,0,
set_thread_area=0xfa0+243,4243,2,
get_thread_area=0xfa0+244,4244,2,
exit_group=0xfa0+252,4252,1,
rizin-0.7.4/librz/syscall/d/darwin-x86-64.sdb.txt 0000664 0001750 0001750 00000033447 14731035230 020715 0 ustar sophie sophie _=0x80
exit=0x80,0x2000001,1
fork=0x80,0x2000002,0
read=0x80,0x2000003,3
write=0x80,0x2000004,3
open=0x80,0x2000005,3
close=0x80,0x2000006,1
wait4=0x80,0x2000007,4
link=0x80,0x2000009,2
unlink=0x80,0x200000a,1
chdir=0x80,0x200000c,1
fchdir=0x80,0x200000d,1
mknod=0x80,0x200000e,3
chmod=0x80,0x200000f,2
chown=0x80,0x2000010,3
getfsstat=0x80,0x2000012,3
getpid=0x80,0x2000014,0
setuid=0x80,0x2000017,1
getuid=0x80,0x2000018,0
geteuid=0x80,0x2000019,0
ptrace=0x80,0x200001a,4
recvmsg=0x80,0x200001b,3
sendmsg=0x80,0x200001c,3
recvfrom=0x80,0x200001d,6
accept=0x80,0x200001e,3
getpeername=0x80,0x200001f,3
getsockname=0x80,0x2000020,3
access=0x80,0x2000021,2
chflags=0x80,0x2000022,2
fchflags=0x80,0x2000023,2
sync=0x80,0x2000024,0
kill=0x80,0x2000025,3
getppid=0x80,0x2000027,0
dup=0x80,0x2000029,1
pipe=0x80,0x200002a,0
getegid=0x80,0x200002b,0
sigaction=0x80,0x200002e,3
getgid=0x80,0x200002f,0
sigprocmask=0x80,0x2000030,3
getlogin=0x80,0x2000031,2
setlogin=0x80,0x2000032,1
acct=0x80,0x2000033,1
sigpending=0x80,0x2000034,1
sigaltstack=0x80,0x2000035,2
ioctl=0x80,0x2000036,3
reboot=0x80,0x2000037,2
revoke=0x80,0x2000038,1
symlink=0x80,0x2000039,2
readlink=0x80,0x200003a,3
execve=0x80,0x200003b,3
umask=0x80,0x200003c,1
chroot=0x80,0x200003d,1
msync=0x80,0x2000041,3
vfork=0x80,0x2000042,0
munmap=0x80,0x2000049,2
mprotect=0x80,0x200004a,3
madvise=0x80,0x200004b,3
mincore=0x80,0x200004e,3
getgroups=0x80,0x200004f,2
setgroups=0x80,0x2000050,2
getpgrp=0x80,0x2000051,0
setpgid=0x80,0x2000052,2
setitimer=0x80,0x2000053,3
swapon=0x80,0x2000055,0
getitimer=0x80,0x2000056,2
getdtablesize=0x80,0x2000059,0
dup2=0x80,0x200005a,2
fcntl=0x80,0x200005c,3
select=0x80,0x200005d,5
fsync=0x80,0x200005f,1
setpriority=0x80,0x2000060,3
socket=0x80,0x2000061,3
connect=0x80,0x2000062,3
getpriority=0x80,0x2000064,2
bind=0x80,0x2000068,3
setsockopt=0x80,0x2000069,5
listen=0x80,0x200006a,2
sigsuspend=0x80,0x200006f,1
gettimeofday=0x80,0x2000074,3
getrusage=0x80,0x2000075,2
getsockopt=0x80,0x2000076,5
readv=0x80,0x2000078,3
writev=0x80,0x2000079,3
settimeofday=0x80,0x200007a,2
fchown=0x80,0x200007b,3
fchmod=0x80,0x200007c,2
setreuid=0x80,0x200007e,2
setregid=0x80,0x200007f,2
rename=0x80,0x2000080,2
flock=0x80,0x2000083,2
mkfifo=0x80,0x2000084,2
sendto=0x80,0x2000085,6
shutdown=0x80,0x2000086,2
socketpair=0x80,0x2000087,4
mkdir=0x80,0x2000088,2
rmdir=0x80,0x2000089,1
utimes=0x80,0x200008a,2
futimes=0x80,0x200008b,2
adjtime=0x80,0x200008c,2
gethostuuid=0x80,0x200008e,3
setsid=0x80,0x2000093,0
getpgid=0x80,0x2000097,1
setprivexec=0x80,0x2000098,1
pread=0x80,0x2000099,4
pwrite=0x80,0x200009a,4
nfssvc=0x80,0x200009b,2
statfs=0x80,0x200009d,2
fstatfs=0x80,0x200009e,2
unmount=0x80,0x200009f,2
getfh=0x80,0x20000a1,2
quotactl=0x80,0x20000a5,4
mount=0x80,0x20000a7,4
csops=0x80,0x20000a9,4
csops_audittoken=0x80,0x20000aa,5
waitid=0x80,0x20000ad,4
kdebug_typefilter=0x80,0x20000b1,2
kdebug_trace_string=0x80,0x20000b2,3
kdebug_trace64=0x80,0x20000b3,5
kdebug_trace=0x80,0x20000b4,5
setgid=0x80,0x20000b5,1
setegid=0x80,0x20000b6,1
seteuid=0x80,0x20000b7,1
sigreturn=0x80,0x20000b8,2
thread_selfcounts=0x80,0x20000ba,3
fdatasync=0x80,0x20000bb,1
stat=0x80,0x20000bc,2
fstat=0x80,0x20000bd,2
lstat=0x80,0x20000be,2
pathconf=0x80,0x20000bf,2
fpathconf=0x80,0x20000c0,2
getrlimit=0x80,0x20000c2,2
setrlimit=0x80,0x20000c3,2
getdirentries=0x80,0x20000c4,4
mmap=0x80,0x20000c5,6
lseek=0x80,0x20000c7,3
truncate=0x80,0x20000c8,2
ftruncate=0x80,0x20000c9,2
sysctl=0x80,0x20000ca,6
mlock=0x80,0x20000cb,2
munlock=0x80,0x20000cc,2
undelete=0x80,0x20000cd,1
open_dprotected_np=0x80,0x20000d8,5
getattrlist=0x80,0x20000dc,5
setattrlist=0x80,0x20000dd,5
getdirentriesattr=0x80,0x20000de,8
exchangedata=0x80,0x20000df,3
searchfs=0x80,0x20000e1,6
delete=0x80,0x20000e2,1
copyfile=0x80,0x20000e3,4
fgetattrlist=0x80,0x20000e4,5
fsetattrlist=0x80,0x20000e5,5
poll=0x80,0x20000e6,3
watchevent=0x80,0x20000e7,2
waitevent=0x80,0x20000e8,2
modwatch=0x80,0x20000e9,2
getxattr=0x80,0x20000ea,6
fgetxattr=0x80,0x20000eb,6
setxattr=0x80,0x20000ec,6
fsetxattr=0x80,0x20000ed,6
removexattr=0x80,0x20000ee,3
fremovexattr=0x80,0x20000ef,3
listxattr=0x80,0x20000f0,4
flistxattr=0x80,0x20000f1,4
fsctl=0x80,0x20000f2,4
initgroups=0x80,0x20000f3,3
posix_spawn=0x80,0x20000f4,5
ffsctl=0x80,0x20000f5,4
nfsclnt=0x80,0x20000f7,2
fhopen=0x80,0x20000f8,2
minherit=0x80,0x20000fa,3
semsys=0x80,0x20000fb,5
msgsys=0x80,0x20000fc,5
shmsys=0x80,0x20000fd,4
semctl=0x80,0x20000fe,4
semget=0x80,0x20000ff,3
semop=0x80,0x2000100,3
msgctl=0x80,0x2000102,3
msgget=0x80,0x2000103,2
msgsnd=0x80,0x2000104,4
msgrcv=0x80,0x2000105,5
shmat=0x80,0x2000106,3
shmctl=0x80,0x2000107,3
shmdt=0x80,0x2000108,1
shmget=0x80,0x2000109,3
shm_open=0x80,0x200010a,3
shm_unlink=0x80,0x200010b,1
sem_open=0x80,0x200010c,4
sem_close=0x80,0x200010d,1
sem_unlink=0x80,0x200010e,1
sem_wait=0x80,0x200010f,1
sem_trywait=0x80,0x2000110,1
sem_post=0x80,0x2000111,1
sysctlbyname=0x80,0x2000112,6
open_extended=0x80,0x2000115,6
umask_extended=0x80,0x2000116,2
stat_extended=0x80,0x2000117,4
lstat_extended=0x80,0x2000118,4
fstat_extended=0x80,0x2000119,4
chmod_extended=0x80,0x200011a,5
fchmod_extended=0x80,0x200011b,5
access_extended=0x80,0x200011c,4
settid=0x80,0x200011d,2
gettid=0x80,0x200011e,2
setsgroups=0x80,0x200011f,2
getsgroups=0x80,0x2000120,2
setwgroups=0x80,0x2000121,2
getwgroups=0x80,0x2000122,2
mkfifo_extended=0x80,0x2000123,5
mkdir_extended=0x80,0x2000124,5
identitysvc=0x80,0x2000125,2
shared_region_check_np=0x80,0x2000126,1
vm_pressure_monitor=0x80,0x2000128,3
psynch_rw_longrdlock=0x80,0x2000129,5
psynch_rw_yieldwrlock=0x80,0x200012a,5
psynch_rw_downgrade=0x80,0x200012b,5
psynch_rw_upgrade=0x80,0x200012c,5
psynch_mutexwait=0x80,0x200012d,5
psynch_mutexdrop=0x80,0x200012e,5
psynch_cvbroad=0x80,0x200012f,7
psynch_cvsignal=0x80,0x2000130,8
psynch_cvwait=0x80,0x2000131,8
psynch_rw_rdlock=0x80,0x2000132,5
psynch_rw_wrlock=0x80,0x2000133,5
psynch_rw_unlock=0x80,0x2000134,5
psynch_rw_unlock2=0x80,0x2000135,5
getsid=0x80,0x2000136,1
settid_with_pid=0x80,0x2000137,2
psynch_cvclrprepost=0x80,0x2000138,7
aio_fsync=0x80,0x2000139,2
aio_return=0x80,0x200013a,1
aio_suspend=0x80,0x200013b,3
aio_cancel=0x80,0x200013c,2
aio_error=0x80,0x200013d,1
aio_read=0x80,0x200013e,1
aio_write=0x80,0x200013f,1
lio_listio=0x80,0x2000140,4
iopolicysys=0x80,0x2000142,2
process_policy=0x80,0x2000143,7
mlockall=0x80,0x2000144,1
munlockall=0x80,0x2000145,1
issetugid=0x80,0x2000147,0
__pthread_kill=0x80,0x2000148,2
__pthread_sigmask=0x80,0x2000149,3
__sigwait=0x80,0x200014a,2
__disable_threadsignal=0x80,0x200014b,1
__pthread_markcancel=0x80,0x200014c,1
__pthread_canceled=0x80,0x200014d,1
__semwait_signal=0x80,0x200014e,6
proc_info=0x80,0x2000150,6
sendfile=0x80,0x2000151,6
stat64=0x80,0x2000152,2
fstat64=0x80,0x2000153,2
lstat64=0x80,0x2000154,2
stat64_extended=0x80,0x2000155,4
lstat64_extended=0x80,0x2000156,4
fstat64_extended=0x80,0x2000157,4
getdirentries64=0x80,0x2000158,4
statfs64=0x80,0x2000159,2
fstatfs64=0x80,0x200015a,2
getfsstat64=0x80,0x200015b,3
__pthread_chdir=0x80,0x200015c,1
__pthread_fchdir=0x80,0x200015d,1
audit=0x80,0x200015e,2
auditon=0x80,0x200015f,3
getauid=0x80,0x2000161,1
setauid=0x80,0x2000162,1
getaudit_addr=0x80,0x2000165,2
setaudit_addr=0x80,0x2000166,2
auditctl=0x80,0x2000167,1
bsdthread_create=0x80,0x2000168,5
bsdthread_terminate=0x80,0x2000169,4
kqueue=0x80,0x200016a,0
kevent=0x80,0x200016b,6
lchown=0x80,0x200016c,3
bsdthread_register=0x80,0x200016e,7
workq_open=0x80,0x200016f,0
workq_kernreturn=0x80,0x2000170,4
kevent64=0x80,0x2000171,7
__old_semwait_signal=0x80,0x2000172,5
__old_semwait_signal_nocancel=0x80,0x2000173,5
thread_selfid=0x80,0x2000174,0
ledger=0x80,0x2000175,4
kevent_qos=0x80,0x2000176,8
kevent_id=0x80,0x2000177,8
__mac_execve=0x80,0x200017c,4
__mac_syscall=0x80,0x200017d,3
__mac_get_file=0x80,0x200017e,2
__mac_set_file=0x80,0x200017f,2
__mac_get_link=0x80,0x2000180,2
__mac_set_link=0x80,0x2000181,2
__mac_get_proc=0x80,0x2000182,1
__mac_set_proc=0x80,0x2000183,1
__mac_get_fd=0x80,0x2000184,2
__mac_set_fd=0x80,0x2000185,2
__mac_get_pid=0x80,0x2000186,2
pselect=0x80,0x200018a,6
pselect_nocancel=0x80,0x200018b,6
read_nocancel=0x80,0x200018c,3
write_nocancel=0x80,0x200018d,3
open_nocancel=0x80,0x200018e,3
close_nocancel=0x80,0x200018f,1
wait4_nocancel=0x80,0x2000190,4
recvmsg_nocancel=0x80,0x2000191,3
sendmsg_nocancel=0x80,0x2000192,3
recvfrom_nocancel=0x80,0x2000193,6
accept_nocancel=0x80,0x2000194,3
msync_nocancel=0x80,0x2000195,3
fcntl_nocancel=0x80,0x2000196,3
select_nocancel=0x80,0x2000197,5
fsync_nocancel=0x80,0x2000198,1
connect_nocancel=0x80,0x2000199,3
sigsuspend_nocancel=0x80,0x200019a,1
readv_nocancel=0x80,0x200019b,3
writev_nocancel=0x80,0x200019c,3
sendto_nocancel=0x80,0x200019d,6
pread_nocancel=0x80,0x200019e,4
pwrite_nocancel=0x80,0x200019f,4
waitid_nocancel=0x80,0x20001a0,4
poll_nocancel=0x80,0x20001a1,3
msgsnd_nocancel=0x80,0x20001a2,4
msgrcv_nocancel=0x80,0x20001a3,5
sem_wait_nocancel=0x80,0x20001a4,1
aio_suspend_nocancel=0x80,0x20001a5,3
__sigwait_nocancel=0x80,0x20001a6,2
__semwait_signal_nocancel=0x80,0x20001a7,6
__mac_mount=0x80,0x20001a8,5
__mac_get_mount=0x80,0x20001a9,2
__mac_getfsstat=0x80,0x20001aa,5
fsgetpath=0x80,0x20001ab,4
audit_session_self=0x80,0x20001ac,0
audit_session_join=0x80,0x20001ad,1
fileport_makeport=0x80,0x20001ae,2
fileport_makefd=0x80,0x20001af,1
audit_session_port=0x80,0x20001b0,2
pid_suspend=0x80,0x20001b1,1
pid_resume=0x80,0x20001b2,1
pid_hibernate=0x80,0x20001b3,1
pid_shutdown_sockets=0x80,0x20001b4,2
shared_region_map_and_slide_np=0x80,0x20001b6,6
kas_info=0x80,0x20001b7,3
memorystatus_control=0x80,0x20001b8,5
guarded_open_np=0x80,0x20001b9,5
guarded_close_np=0x80,0x20001ba,2
guarded_kqueue_np=0x80,0x20001bb,2
change_fdguard_np=0x80,0x20001bc,6
usrctl=0x80,0x20001bd,1
proc_rlimit_control=0x80,0x20001be,3
connectx=0x80,0x20001bf,8
disconnectx=0x80,0x20001c0,3
peeloff=0x80,0x20001c1,2
socket_delegate=0x80,0x20001c2,4
telemetry=0x80,0x20001c3,6
proc_uuid_policy=0x80,0x20001c4,4
memorystatus_get_level=0x80,0x20001c5,1
system_override=0x80,0x20001c6,2
vfs_purge=0x80,0x20001c7,0
sfi_ctl=0x80,0x20001c8,4
sfi_pidctl=0x80,0x20001c9,4
coalition=0x80,0x20001ca,3
coalition_info=0x80,0x20001cb,4
necp_match_policy=0x80,0x20001cc,3
getattrlistbulk=0x80,0x20001cd,5
clonefileat=0x80,0x20001ce,5
openat=0x80,0x20001cf,4
openat_nocancel=0x80,0x20001d0,4
renameat=0x80,0x20001d1,4
faccessat=0x80,0x20001d2,4
fchmodat=0x80,0x20001d3,4
fchownat=0x80,0x20001d4,5
fstatat=0x80,0x20001d5,4
fstatat64=0x80,0x20001d6,4
linkat=0x80,0x20001d7,5
unlinkat=0x80,0x20001d8,3
readlinkat=0x80,0x20001d9,4
symlinkat=0x80,0x20001da,3
mkdirat=0x80,0x20001db,3
getattrlistat=0x80,0x20001dc,6
proc_trace_log=0x80,0x20001dd,2
bsdthread_ctl=0x80,0x20001de,4
openbyid_np=0x80,0x20001df,3
recvmsg_x=0x80,0x20001e0,4
sendmsg_x=0x80,0x20001e1,4
thread_selfusage=0x80,0x20001e2,0
csrctl=0x80,0x20001e3,3
guarded_open_dprotected_np=0x80,0x20001e4,7
guarded_write_np=0x80,0x20001e5,4
guarded_pwrite_np=0x80,0x20001e6,5
guarded_writev_np=0x80,0x20001e7,4
renameatx_np=0x80,0x20001e8,5
mremap_encrypted=0x80,0x20001e9,5
netagent_trigger=0x80,0x20001ea,2
stack_snapshot_with_config=0x80,0x20001eb,3
microstackshot=0x80,0x20001ec,3
grab_pgo_data=0x80,0x20001ed,4
persona=0x80,0x20001ee,5
work_interval_ctl=0x80,0x20001f3,4
getentropy=0x80,0x20001f4,2
necp_open=0x80,0x20001f5,1
necp_client_action=0x80,0x20001f6,6
ulock_wait=0x80,0x2000203,4
ulock_wake=0x80,0x2000204,3
fclonefileat=0x80,0x2000205,4
fs_snapshot=0x80,0x2000206,6
terminate_with_payload=0x80,0x2000208,7
abort_with_payload=0x80,0x2000209,6
necp_session_open=0x80,0x200020a,1
necp_session_action=0x80,0x200020b,6
setattrlistat=0x80,0x200020c,6
net_qos_guideline=0x80,0x200020d,2
fmount=0x80,0x200020e,4
ntp_adjtime=0x80,0x200020f,1
ntp_gettime=0x80,0x2000210,1
os_fault_with_payload=0x80,0x2000211,6
_kernelrpc_mach_vm_allocate_trap=0x80,0x100000a,4
_kernelrpc_mach_vm_purgable_control_trap=0x80,0x100000b,4
_kernelrpc_mach_vm_deallocate_trap=0x80,0x100000c,3
_kernelrpc_mach_vm_protect_trap=0x80,0x100000e,5
_kernelrpc_mach_vm_map_trap=0x80,0x100000f,6
_kernelrpc_mach_port_allocate_trap=0x80,0x1000010,3
_kernelrpc_mach_port_destroy_trap=0x80,0x1000011,2
_kernelrpc_mach_port_deallocate_trap=0x80,0x1000012,2
_kernelrpc_mach_port_mod_refs_trap=0x80,0x1000013,4
_kernelrpc_mach_port_move_member_trap=0x80,0x1000014,3
_kernelrpc_mach_port_insert_right_trap=0x80,0x1000015,4
_kernelrpc_mach_port_insert_member_trap=0x80,0x1000016,3
_kernelrpc_mach_port_extract_member_trap=0x80,0x1000017,3
_kernelrpc_mach_port_construct_trap=0x80,0x1000018,4
_kernelrpc_mach_port_destruct_trap=0x80,0x1000019,4
mach_reply_port=0x80,0x100001a,0
thread_self_trap=0x80,0x100001b,0
task_self_trap=0x80,0x100001c,0
host_self_trap=0x80,0x100001d,0
mach_msg_trap=0x80,0x100001f,7
mach_msg_overwrite_trap=0x80,0x1000020,8
semaphore_signal_trap=0x80,0x1000021,1
semaphore_signal_all_trap=0x80,0x1000022,1
semaphore_signal_thread_trap=0x80,0x1000023,2
semaphore_wait_trap=0x80,0x1000024,1
semaphore_wait_signal_trap=0x80,0x1000025,2
semaphore_timedwait_trap=0x80,0x1000026,3
semaphore_timedwait_signal_trap=0x80,0x1000027,4
_kernelrpc_mach_port_guard_trap=0x80,0x1000029,4
_kernelrpc_mach_port_unguard_trap=0x80,0x100002a,3
mach_generate_activity_id=0x80,0x100002b,3
task_name_for_pid=0x80,0x100002c,3
task_for_pid=0x80,0x100002d,3
pid_for_task=0x80,0x100002e,2
macx_swapon=0x80,0x1000030,4
macx_swapoff=0x80,0x1000031,2
thread_get_special_reply_port=0x80,0x1000032,0
macx_triggers=0x80,0x1000033,4
macx_backing_store_suspend=0x80,0x1000034,1
macx_backing_store_recovery=0x80,0x1000035,1
pfz_exit=0x80,0x100003a,0
swtch_pri=0x80,0x100003b,0
swtch=0x80,0x100003c,0
thread_switch=0x80,0x100003d,3
clock_sleep_trap=0x80,0x100003e,5
host_create_mach_voucher_trap=0x80,0x1000046,4
mach_voucher_extract_attr_recipe_trap=0x80,0x1000048,4
mach_timebase_info_trap=0x80,0x1000059,1
mach_wait_until_trap=0x80,0x100005a,1
mk_timer_create_trap=0x80,0x100005b,0
mk_timer_destroy_trap=0x80,0x100005c,1
mk_timer_arm_trap=0x80,0x100005d,2
mk_timer_cancel_trap=0x80,0x100005e,2
mk_timer_arm_leeway_trap=0x80,0x100005f,4
iokit_user_client_trap=0x80,0x1000064,8
rizin-0.7.4/librz/syscall/d/openbsd-x86-32.sdb.txt 0000664 0001750 0001750 00000007200 14731035230 021042 0 ustar sophie sophie syscall=0x80,0,2,
exit=0x80,1,1,
fork=0x80,2,0,
read=0x80,3,3,
write=0x80,4,3,
open=0x80,5,3,
close=0x80,6,1,
wait4=0x80,7,4,
link=0x80,9,2,
unlink=0x80,10,1,
chdir=0x80,12,1,
fchdir=0x80,13,1,
mknod=0x80,14,3,
chmod=0x80,15,2,
chown=0x80,16,3,
break=0x80,17,1,
getpid=0x80,20,0,
mount=0x80,21,4,
unmount=0x80,22,2,
setuid=0x80,23,1,
getuid=0x80,24,0,
geteuid=0x80,25,0,
ptrace=0x80,26,4,
recvmsg=0x80,27,3,
sendmsg=0x80,28,3,
recvfrom=0x80,29,6,
accept=0x80,30,3,
getpeername=0x80,31,3,
getsockname=0x80,32,3,
access=0x80,33,2,
chflags=0x80,34,2,
fchflags=0x80,35,2,
sync=0x80,36,0,
kill=0x80,37,2,
getppid=0x80,39,0,
dup=0x80,41,1,
opipe=0x80,42,0,
getegid=0x80,43,0,
profil=0x80,44,4,
ktrace=0x80,45,4,
sigaction=0x80,46,3,
getgid=0x80,47,0,
sigprocmask=0x80,48,2,
getlogin=0x80,49,2,
setlogin=0x80,50,1,
acct=0x80,51,1,
sigpending=0x80,52,0,
osigaltstack=0x80,53,2,
ioctl=0x80,54,3,
reboot=0x80,55,1,
revoke=0x80,56,1,
symlink=0x80,57,2,
readlink=0x80,58,3,
execve=0x80,59,3,
umask=0x80,60,1,
chroot=0x80,61,1,
vfork=0x80,66,0,
sbrk=0x80,69,1,
sstk=0x80,70,1,
munmap=0x80,73,2,
mprotect=0x80,74,3,
madvise=0x80,75,3,
mincore=0x80,78,3,
getgroups=0x80,79,2,
setgroups=0x80,80,2,
getpgrp=0x80,81,0,
setpgid=0x80,82,2,
setitimer=0x80,83,3,
getitimer=0x80,86,2,
dup2=0x80,90,2,
fcntl=0x80,92,3,
select=0x80,93,5,
fsync=0x80,95,1,
setpriority=0x80,96,3,
socket=0x80,97,3,
connect=0x80,98,3,
getpriority=0x80,100,2,
sigreturn=0x80,103,1,
bind=0x80,104,3,
setsockopt=0x80,105,5,
listen=0x80,106,2,
sigsuspend=0x80,111,1,
gettimeofday=0x80,116,2,
getrusage=0x80,117,2,
getsockopt=0x80,118,5,
readv=0x80,120,3,
writev=0x80,121,3,
settimeofday=0x80,122,2,
fchown=0x80,123,3,
fchmod=0x80,124,2,
setreuid=0x80,126,2,
setregid=0x80,127,2,
rename=0x80,128,2,
flock=0x80,131,2,
mkfifo=0x80,132,2,
sendto=0x80,133,6,
shutdown=0x80,134,2,
socketpair=0x80,135,4,
mkdir=0x80,136,2,
rmdir=0x80,137,1,
utimes=0x80,138,2,
adjtime=0x80,140,2,
setsid=0x80,147,0,
quotactl=0x80,148,4,
nfssvc=0x80,155,2,
getfh=0x80,161,2,
sysarch=0x80,165,2,
pread=0x80,173,5,
pwrite=0x80,174,5,
setgid=0x80,181,1,
setegid=0x80,182,1,
seteuid=0x80,183,1,
lfs_bmapv=0x80,184,3,
lfs_markv=0x80,185,3,
lfs_segclean=0x80,186,2,
lfs_segwait=0x80,187,2,
pathconf=0x80,191,2,
fpathconf=0x80,192,2,
swapctl=0x80,193,3,
getrlimit=0x80,194,2,
setrlimit=0x80,195,2,
getdirentries=0x80,196,4,
mmap=0x80,197,7,
__syscall=0x80,198,2,
lseek=0x80,199,4,
truncate=0x80,200,3,
ftruncate=0x80,201,3,
__sysctl=0x80,202,6,
mlock=0x80,203,2,
munlock=0x80,204,2,
futimes=0x80,206,2,
getpgid=0x80,207,1,
nnpfspioctl=0x80,208,5,
semget=0x80,221,3,
msgget=0x80,225,2,
msgsnd=0x80,226,4,
msgrcv=0x80,227,5,
shmat=0x80,228,3,
shmdt=0x80,230,1,
clock_gettime=0x80,232,2,
clock_settime=0x80,233,2,
clock_getres=0x80,234,2,
nanosleep=0x80,240,2,
minherit=0x80,250,3,
rfork=0x80,251,1,
poll=0x80,252,3,
issetugid=0x80,253,0,
lchown=0x80,254,3,
getsid=0x80,255,1,
msync=0x80,256,3,
pipe=0x80,263,1,
fhopen=0x80,264,2,
preadv=0x80,267,5,
pwritev=0x80,268,5,
kqueue=0x80,269,0,
kevent=0x80,270,6,
mlockall=0x80,271,1,
munlockall=0x80,272,0,
getpeereid=0x80,273,3,
getresuid=0x80,281,3,
setresuid=0x80,282,3,
getresgid=0x80,283,3,
setresgid=0x80,284,3,
mquery=0x80,286,7,
closefrom=0x80,287,1,
sigaltstack=0x80,288,2,
shmget=0x80,289,3,
semop=0x80,290,3,
stat=0x80,291,2,
fstat=0x80,292,2,
lstat=0x80,293,2,
fhstat=0x80,294,2,
__semctl=0x80,295,4,
shmctl=0x80,296,3,
msgctl=0x80,297,3,
sched_yield=0x80,298,0,
getthrid=0x80,299,0,
thrsleep=0x80,300,4,
thrwakeup=0x80,301,2,
threxit=0x80,302,1,
thrsigdivert=0x80,303,3,
__getcwd=0x80,304,2,
adjfreq=0x80,305,2,
getfsstat=0x80,306,3,
statfs=0x80,307,2,
fstatfs=0x80,308,2,
fhstatfs=0x80,309,2,
setrtable=0x80,310,1,
getrtable=0x80,311,0,
rizin-0.7.4/librz/syscall/d/linux-x86-64.sdb.txt 0000664 0001750 0001750 00000017354 14731035230 020567 0 ustar sophie sophie _=0x80
read=0x80,0,3,ipi
write=0x80,1,3,izi
open=0x80,2,3,zxx
close=0x80,3,1,i
stat=0x80,4,2,
fstat=0x80,5,2,
lstat=0x80,6,2,
poll=0x80,7,3,
lseek=0x80,8,3,
mmap=0x80,9,6,
mprotect=0x80,10,3,
munmap=0x80,11,1,
brk=0x80,12,1,
rt_sigaction=0x80,13,3,
rt_sigprocmask=0x80,14,3,
rt_sigreturn=0x80,15,1,
ioctl=0x80,16,3,
pread64=0x80,17,4,
pwrite64=0x80,18,4,
readv=0x80,19,3,
writev=0x80,20,3,
access=0x80,21,2,
pipe=0x80,22,1,
select=0x80,23,5,
sched_yield=0x80,24,0,
mremap=0x80,25,5,
msync=0x80,26,3,
mincore=0x80,27,3,
madvise=0x80,28,3,
shmget=0x80,29,3,
shmat=0x80,30,3,
shmctl=0x80,31,3,
dup=0x80,32,2,
dup2=0x80,33,2,
pause=0x80,34,0,
nanosleep=0x80,35,2,
getitimer=0x80,36,2,
alarm=0x80,37,1,
setitimer=0x80,38,3,
getpid=0x80,39,0,
sendfile=0x80,40,4,
socket=0x80,41,3,
connect=0x80,42,3,
accept=0x80,43,3,
sendto=0x80,44,6,
recvfrom=0x80,45,6,
sendmsg=0x80,46,3,
recvmsg=0x80,47,3,
shutdown=0x80,48,2,
bind=0x80,49,3,
listen=0x80,50,2,
getsockname=0x80,51,3,
getpeername=0x80,52,3,
socketpair=0x80,53,4,
setsockopt=0x80,54,5,
getsockopt=0x80,55,5,
clone=0x80,56,4,
fork=0x80,57,0,
vfork=0x80,58,0,
execve=0x80,59,3,zzz
exit=0x80,60,1,i
wait4=0x80,61,4,
kill=0x80,62,2,
uname=0x80,63,1,
semget=0x80,64,3,
semop=0x80,65,3,
semctl=0x80,66,4,
shmdt=0x80,67,1,
msgget=0x80,68,2,
msgsnd=0x80,69,4,
msgrcv=0x80,70,5,
msgctl=0x80,71,3,
fcntl=0x80,72,3,
flock=0x80,73,2,
fsync=0x80,74,1,
fdatasync=0x80,75,1,
truncate=0x80,76,2,
ftruncate=0x80,77,2,
getdents=0x80,78,3,
getcwd=0x80,79,2,
chdir=0x80,80,1,z
fchdir=0x80,81,1,
rename=0x80,82,2,
mkdir=0x80,83,2,
rmdir=0x80,84,1,
creat=0x80,85,2,zx
link=0x80,86,2,zz
unlink=0x80,87,1,z
symlink=0x80,88,2,
readlink=0x80,89,3,
chmod=0x80,90,2,
fchmod=0x80,91,2,
chown=0x80,92,3,
fchown=0x80,93,3,
lchown=0x80,94,3,
umask=0x80,95,1,
gettimeofday=0x80,96,2,
getrlimit=0x80,97,2,
getrusage=0x80,98,2,
sysinfo=0x80,99,1,
times=0x80,100,1,
ptrace=0x80,101,4,
getuid=0x80,102,0,
syslog=0x80,103,3,
getgid=0x80,104,0,
setuid=0x80,105,1,
setgid=0x80,106,1,
geteuid=0x80,107,0,
getegid=0x80,108,0,
setpgid=0x80,109,2,
getppid=0x80,110,0,
getpgrp=0x80,111,0,
setsid=0x80,112,0,
setreuid=0x80,113,2,
setregid=0x80,114,2,
getgroups=0x80,115,2,
setgroups=0x80,116,2,
setresuid=0x80,117,3,
getresuid=0x80,118,3,
setresgid=0x80,119,3,
getresgid=0x80,120,3,
getpgid=0x80,121,1,
setfsuid=0x80,122,1,
setfsgid=0x80,123,1,
getsid=0x80,124,1,
capget=0x80,125,2,
capset=0x80,126,2,
rt_sigpending=0x80,127,2,
rt_sigtimedwait=0x80,128,4,
rt_sigqueueinfo=0x80,129,3,
rt_sigsuspend=0x80,130,2,
sigaltstack=0x80,131,2,
utime=0x80,132,2,
mknod=0x80,133,3,
uselib=0x80,134,1,
personality=0x80,135,1,
ustat=0x80,136,2,
statfs=0x80,137,2,
fstatfs=0x80,138,2,
sysfs=0x80,139,3,
getpriority=0x80,140,2,
setpriority=0x80,141,3,
sched_setparam=0x80,142,2,
sched_getparam=0x80,143,2,
sched_setscheduler=0x80,144,3,
sched_getscheduler=0x80,145,1,
sched_get_priority_max=0x80,146,1,
sched_get_priority_min=0x80,147,1,
sched_rr_get_interval=0x80,148,2,
mlock=0x80,149,2,
munlock=0x80,150,2,
mlockall=0x80,151,1,
munlockall=0x80,152,0,
vhangup=0x80,153,0,
modify_ldt=0x80,154,3,
pivot_root=0x80,155,2,
sysctl=0x80,156,1,
prctl=0x80,157,5,
arch_prctl=0x80,158,3,
adjtimex=0x80,159,1,
setrlimit=0x80,160,2,
chroot=0x80,161,1,
sync=0x80,162,0,
acct=0x80,163,1,
settimeofday=0x80,164,2,
mount=0x80,165,5,
umount2=0x80,166,2,
swapon=0x80,167,2,
swapoff=0x80,168,1,
reboot=0x80,169,4,
sethostname=0x80,170,2,
setdomainname=0x80,171,2,
iopl=0x80,172,2,
ioperm=0x80,173,3,
create_module=0x80,174,1,
init_module=0x80,175,3,
delete_module=0x80,176,2,
get_kernel_syms=0x80,177,1,
query_module=0x80,178,1,
quotactl=0x80,179,4,
nfsservctl=0x80,180,1,
getpmsg=0x80,181,1,
putpmsg=0x80,182,1,
afs_syscall=0x80,183,1,
tuxcall=0x80,184,1,
security=0x80,185,1,
gettid=0x80,186,0,
readahead=0x80,187,3,
setxattr=0x80,188,5,
lsetxattr=0x80,189,5,
fsetxattr=0x80,190,5,
getxattr=0x80,191,4,
lgetxattr=0x80,192,4,
fgetxattr=0x80,193,4,
listxattr=0x80,194,3,
llistxattr=0x80,195,3,
flistxattr=0x80,196,3,
removexattr=0x80,197,2,
lremovexattr=0x80,198,2,
fremovexattr=0x80,199,2,
tkill=0x80,200,2,
time=0x80,201,1,
futex=0x80,202,6,
sched_setaffinity=0x80,203,3,
sched_getaffinity=0x80,204,3,
set_thread_area=0x80,205,2,
io_setup=0x80,206,2,
io_destroy=0x80,207,1,
io_getevents=0x80,208,4,
io_submit=0x80,209,3,
io_cancel=0x80,210,3,
get_thread_area=0x80,211,2,
lookup_dcookie=0x80,212,3,
epoll_create=0x80,213,1,
epoll_ctl_old=0x80,214,1,
epoll_wait_old=0x80,215,1,
remap_file_pages=0x80,216,5,
getdents64=0x80,217,3,
set_tid_address=0x80,218,1,
restart_syscall=0x80,219,0,
semtimedop=0x80,220,4,
fadvise64=0x80,221,4,
timer_create=0x80,222,3,
timer_settime=0x80,223,4,
timer_gettime=0x80,224,2,
timer_getoverrun=0x80,225,1,
timer_delete=0x80,226,1,
clock_settime=0x80,227,2,
clock_gettime=0x80,228,2,
clock_getres=0x80,229,2,
clock_nanosleep=0x80,230,4,
exit_group=0x80,231,1,
epoll_wait=0x80,232,4,
epoll_ctl=0x80,233,4,
tgkill=0x80,234,3,
utimes=0x80,235,2,
vserver=0x80,236,1,
mbind=0x80,237,6,
set_mempolicy=0x80,238,3,
get_mempolicy=0x80,239,5,
mq_open=0x80,240,4,
mq_unlink=0x80,241,1,
mq_timedsend=0x80,242,5,
mq_timedreceive=0x80,243,5,
mq_notify=0x80,244,2,
mq_getsetattr=0x80,245,3,
kexec_load=0x80,246,4,
waitid=0x80,247,5,
add_key=0x80,248,4,
request_key=0x80,249,4,
keyctl=0x80,250,5,
ioprio_set=0x80,251,3,
ioprio_get=0x80,252,2,
inotify_init=0x80,253,0,
inotify_add_watch=0x80,254,3,
inotify_rm_watch=0x80,255,2,
migrate_pages=0x80,256,4,
openat=0x80,257,4,
mkdirat=0x80,258,3,
mknodat=0x80,259,4,
fchownat=0x80,260,5,
futimesat=0x80,261,3,
newfstatat=0x80,262,4,
unlinkat=0x80,263,3,
renameat=0x80,264,4,
linkat=0x80,265,5,
symlinkat=0x80,266,3,
readlinkat=0x80,267,4,
fchmodat=0x80,268,3,
faccessat=0x80,269,3,
pselect6=0x80,270,6,
ppoll=0x80,271,5,
unshare=0x80,272,1,
set_robust_list=0x80,273,2,
get_robust_list=0x80,274,3,
splice=0x80,275,6,
tee=0x80,276,4,
sync_file_range=0x80,277,4,
vmsplice=0x80,278,4,
move_pages=0x80,279,6,
utimensat=0x80,280,4,
epoll_pwait=0x80,281,6,
signalfd=0x80,282,3,
timerfd_create=0x80,283,2,
eventfd=0x80,284,1,
fallocate=0x80,285,4,
timerfd_settime=0x80,286,4,
timerfd_gettime=0x80,287,2,
accept4=0x80,288,4,
signalfd4=0x80,289,4,
eventfd2=0x80,290,2,
epoll_create1=0x80,291,1,
dup3=0x80,292,3,
pipe2=0x80,293,2,
inotify_init1=0x80,294,1,
preadv=0x80,295,5,
pwritev=0x80,296,5,
rt_tgsigqueueinfo=0x80,297,4,
perf_event_open=0x80,298,5,
recvmmsg=0x80,299,5,
fanotify_init=0x80,300,2,
fanotify_mark=0x80,301,5,
prlimit64=0x80,302,4,
name_to_handle_at=0x80,303,5,
open_by_handle_at=0x80,304,5,
clock_adjtime=0x80,305,2,
syncfs=0x80,306,1,
sendmmsg=0x80,307,4,
setns=0x80,308,2,
getcpu=0x80,309,3,
process_vm_readv=0x80,310,6,
process_vm_writev=0x80,311,6,
kcmp=0x80,312,5,
finit_module=0x80,313,3,
sched_setattr=0x80,314,3,
sched_getattr=0x80,315,4,
renameat2=0x80,316,5,
seccomp=0x80,317,3,
getrandom=0x80,318,3,pii,
memfd_create=0x80,319,2,
kexec_file_load=0x80,320,5,
bpf=0x80,321,3,
execveat=0x80,322,5,
userfaultfd=0x80,323,1,
membarrier=0x80,324,2,
mlock2=0x80,325,3,
copy_file_range=0x80,326,6,
preadv2=0x80,327,6,
pwritev2=0x80,328,6,
pkey_mprotect=0x80,329,4,
pkey_alloc=0x80,330,2,
pkey_free=0x80,331,1,
statx=0x80,332,5,
io_pgetevents=0x80,333,6,
rseq=0x80,334,4,
pidfd_send_signal=0x80,424,4,
io_uring_setup=0x80,425,2,
io_uring_enter=0x80,426,5,
io_uring_register=0x80,427,4,
open_tree=0x80,428,3,
move_mount=0x80,429,5,
fsopen=0x80,430,2,
fsconfig=0x80,431,5,
fsmount=0x80,432,3,
fspick=0x80,433,3,
pidfd_open=0x80,434,2,
clone3=0x80,435,2,
close_range=0x80,436,3,
openat2=0x80,437,4,
pidfd_getfd=0x80,438,3,
faccessat2=0x80,439,4,
process_madvise=0x80,440,5,
epoll_pwait2=0x80,441,6,
mount_setattr=0x80,442,5,
quotactl_fd=0x80,443,4,
landlock_create_ruleset=0x80,444,3,
landlock_add_rule=0x80,445,4,
landlock_restrict_self=0x80,446,2,
memfd_secret=0x80,447,1,
process_mrelease=0x80,448,2,
futex_waitv=0x80,449,5,
set_mempolicy_home_node=0x80,450,4,
cachestat=0x80,451,4,
rizin-0.7.4/librz/syscall/syscall.c 0000664 0001750 0001750 00000023503 14731035230 016632 0 ustar sophie sophie // SPDX-FileCopyrightText: 2008-2020 pancake
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#include
RZ_LIB_VERSION(rz_syscall);
RZ_API RzSyscall *rz_syscall_ref(RzSyscall *sc) {
sc->refs++;
return sc;
}
/**
* \brief Creates a new RzSysregItem type
*
* \param name Name of the SysregItem (sysregitem->name)
*/
RZ_API RZ_OWN RzSysregItem *rz_sysreg_item_new(RZ_NULLABLE const char *name) {
RzSysregItem *sysregitem = RZ_NEW0(RzSysregItem);
if (!sysregitem) {
return NULL;
}
sysregitem->comment = NULL;
sysregitem->type = NULL;
sysregitem->name = name ? strdup(name) : NULL;
return sysregitem;
}
static void free_port_kv(HtUPKv *kv) {
rz_sysreg_item_free(kv->value);
}
/**
* \brief Creates a new RzSysregDB type
*/
RZ_API RzSysregsDB *rz_sysregs_db_new() {
RzSysregsDB *sysregdb = RZ_NEW0(RzSysregsDB);
if (!sysregdb) {
return NULL;
}
sysregdb->port = ht_up_new(NULL, free_port_kv, NULL);
if (!sysregdb->port) {
free(sysregdb);
return NULL;
}
return sysregdb;
}
/**
* \brief Frees a RzSysregDB type
*/
RZ_API void rz_sysregs_db_free(RzSysregsDB *sysregdb) {
if (!sysregdb) {
return;
}
ht_up_free(sysregdb->port);
free(sysregdb);
}
/**
* \brief Creates a new RzSyscall type
*/
RZ_API RzSyscall *rz_syscall_new(void) {
RzSyscall *rs = RZ_NEW0(RzSyscall);
if (rs) {
rs->srdb = rz_sysregs_db_new(); // sysregs database
rs->db = sdb_new0();
}
return rs;
}
/**
* \brief Frees an RzSyscall type
*/
RZ_API void rz_syscall_free(RzSyscall *s) {
if (s) {
if (s->refs > 0) {
s->refs--;
return;
}
sdb_free(s->db);
free(s->os);
free(s->cpu);
free(s->arch);
rz_sysregs_db_free(s->srdb);
free(s);
}
}
/**
* \brief Frees an RzSysregItem type
*/
RZ_API void rz_sysreg_item_free(RzSysregItem *s) {
if (!s) {
return;
}
free(s->comment);
free(s->name);
free(s->type);
free(s);
}
static bool load_sdb(Sdb **db, const char *name) {
rz_return_val_if_fail(db, false);
char *sdb_path = rz_path_system(RZ_SDB);
char *file_name = rz_str_newf("%s.sdb", name);
char *file = rz_file_path_join(sdb_path, file_name);
free(file_name);
free(sdb_path);
if (rz_file_exists(file)) {
if (*db) {
sdb_reset(*db);
sdb_open(*db, file);
} else {
*db = sdb_new(0, file, 0);
}
free(file);
return true;
}
free(file);
return false;
}
static inline bool syscall_reload_needed(RzSyscall *s, const char *os, const char *arch, int bits) {
if (!s->os || strcmp(s->os, os)) {
return true;
}
if (!s->arch || strcmp(s->arch, arch)) {
return true;
}
return s->bits != bits;
}
static inline bool sysregs_reload_needed(RzSyscall *s, const char *arch, int bits, const char *cpu) {
if (!s->arch || strcmp(s->arch, arch)) {
return true;
}
if (s->bits != bits) {
return true;
}
return !s->cpu || strcmp(s->cpu, cpu);
}
static bool sdb_load_sysregs(RzSysregsDB *sysregdb, Sdb *sdb) {
rz_return_val_if_fail(sysregdb && sdb, false);
RzSysregItem *sysregitem;
SdbKv *kv;
SdbListIter *iter;
SdbList *l = sdb_foreach_list(sdb, false);
char *argument_key, *comment, *name;
ls_foreach (l, iter, kv) {
if (!strcmp(sdbkv_value(kv), "mmio") || !strcmp(sdbkv_value(kv), "reg")) {
name = sdbkv_key(kv);
sysregitem = rz_sysreg_item_new(name);
argument_key = rz_str_newf("%s.address", name);
if (!argument_key) {
rz_sysreg_item_free(sysregitem);
return false;
}
ut64 address = sdb_num_get(sdb, argument_key, NULL);
free(argument_key);
if (!address) {
rz_sysreg_item_free(sysregitem);
return false;
}
argument_key = rz_str_newf("%s.comment", name);
comment = sdb_get(sdb, argument_key, NULL);
free(argument_key);
sysregitem->type = strdup(sdbkv_value(kv));
sysregitem->comment = comment;
ht_up_insert(sysregdb->port, address, sysregitem);
}
}
ls_free(l);
return true;
}
static bool sdb_load_by_path(RZ_NONNULL RzSysregsDB *sysregdb, const char *path) {
Sdb *db = sdb_new(0, path, 0);
bool result = sdb_load_sysregs(sysregdb, db);
sdb_close(db);
sdb_free(db);
return result;
}
/**
* \brief Loads the RzSysregDB from the path to the hashtable
*
* \param s reference to RzSysregDB
* \param path reference to path of the SDB file
*/
RZ_API bool rz_sysreg_load_sdb(RzSysregsDB *sysregdb, const char *path) {
if (!rz_file_exists(path) || !sysregdb) {
return false;
}
return sdb_load_by_path(sysregdb, path);
}
/**
* \brief Sets the architecture for sysregs during analysis and
* loads up the sysregs SDB database
*
* \param s reference to RzSyscall
* \param arch reference to value of asm.arch
* \param regs_dir path where registers SDB files are located
*/
RZ_API bool rz_sysreg_set_arch(RzSyscall *s, RZ_NONNULL const char *arch, RZ_NONNULL const char *regs_dir) {
rz_return_val_if_fail(s && regs_dir && arch, false);
char buf[60];
char *path = rz_file_path_join(regs_dir, rz_strf(buf, "%s-%s-%d.sdb", arch, s->cpu, s->bits));
if (!path) {
return true;
}
rz_sysregs_db_free(s->srdb);
s->srdb = rz_sysregs_db_new();
if (!rz_sysreg_load_sdb(s->srdb, path)) {
free(path);
rz_sysregs_db_free(s->srdb);
s->srdb = rz_sysregs_db_new();
return false;
}
free(path);
return true;
}
// TODO: should be renamed to rz_syscall_use();
RZ_API bool rz_syscall_setup(RzSyscall *s, const char *arch, int bits, const char *cpu, const char *os) {
bool syscall_changed, sysregs_changed;
if (!os || !*os) {
os = RZ_SYS_OS;
}
if (!arch) {
arch = RZ_SYS_ARCH;
}
if (!cpu) {
cpu = arch;
}
syscall_changed = syscall_reload_needed(s, os, arch, bits);
sysregs_changed = sysregs_reload_needed(s, arch, bits, cpu);
free(s->os);
s->os = strdup(os);
free(s->cpu);
s->cpu = strdup(cpu);
free(s->arch);
s->arch = strdup(arch);
s->bits = bits;
if (!strcmp(os, "any")) { // ignored
return true;
} else if (!strcmp(os, "darwin") || !strcmp(os, "osx") || !strcmp(os, "macos")) {
os = "darwin";
}
if (syscall_changed) {
char *dbName = rz_str_newf(RZ_JOIN_2_PATHS("syscall", "%s-%s-%d"),
os, arch, bits);
if (dbName) {
if (!load_sdb(&s->db, dbName)) {
sdb_free(s->db);
s->db = NULL;
}
free(dbName);
}
}
if (sysregs_changed) {
char *regs_dir = rz_path_system(RZ_SDB_REG);
rz_sysreg_set_arch(s, arch, regs_dir);
free(regs_dir);
}
if (s->fd) {
fclose(s->fd);
s->fd = NULL;
}
return true;
}
RZ_API RzSyscallItem *rz_syscall_item_new_from_string(const char *name, const char *s) {
RzSyscallItem *si;
char *o;
if (!name || !s) {
return NULL;
}
o = strdup(s);
int cols = rz_str_split(o, ',');
if (cols < 3) {
free(o);
return NULL;
}
si = RZ_NEW0(RzSyscallItem);
if (!si) {
free(o);
return NULL;
}
si->name = strdup(name);
si->swi = (int)rz_num_get(NULL, rz_str_word_get0(o, 0));
si->num = (int)rz_num_get(NULL, rz_str_word_get0(o, 1));
si->args = (int)rz_num_get(NULL, rz_str_word_get0(o, 2));
si->sargs = calloc(si->args + 1, sizeof(char));
if (!si->sargs) {
free(si);
free(o);
return NULL;
}
if (cols > 3) {
strncpy(si->sargs, rz_str_word_get0(o, 3), si->args);
}
free(o);
return si;
}
RZ_API void rz_syscall_item_free(RzSyscallItem *si) {
if (!si) {
return;
}
free(si->name);
free(si->sargs);
free(si);
}
static int getswi(RzSyscall *s, int swi) {
if (s && swi == -1) {
return rz_syscall_get_swi(s);
}
return swi;
}
RZ_API int rz_syscall_get_swi(RzSyscall *s) {
return (int)sdb_num_get(s->db, "_", NULL);
}
RZ_API RzSyscallItem *rz_syscall_get(RzSyscall *s, int num, int swi) {
rz_return_val_if_fail(s, NULL);
if (!s->db) {
return NULL;
}
const char *ret, *ret2, *key;
char tmpbuf[64] = { 0 };
swi = getswi(s, swi);
if (swi < 16) {
key = rz_strf(tmpbuf, "%d.%d", swi, num);
} else {
key = rz_strf(tmpbuf, "0x%02x.%d", swi, num);
}
ret = sdb_const_get(s->db, key, 0);
if (!ret) {
key = rz_strf(tmpbuf, "0x%02x.0x%02x", swi, num); // Workaround until Syscall SDB is fixed
ret = sdb_const_get(s->db, key, 0);
if (!ret) {
key = rz_strf(tmpbuf, "0x%02x.%d", num, swi); // Workaround until Syscall SDB is fixed
ret = sdb_const_get(s->db, key, 0);
if (!ret) {
return NULL;
}
}
}
ret2 = sdb_const_get(s->db, ret, 0);
if (!ret2) {
return NULL;
}
return rz_syscall_item_new_from_string(ret, ret2);
}
RZ_API int rz_syscall_get_num(RzSyscall *s, const char *str) {
rz_return_val_if_fail(s && str, -1);
if (!s->db) {
return -1;
}
int sn = (int)sdb_array_get_num(s->db, str, 1, NULL);
if (sn == 0) {
return (int)sdb_array_get_num(s->db, str, 0, NULL);
}
return sn;
}
RZ_API const char *rz_syscall_get_i(RzSyscall *s, int num, int swi) {
rz_return_val_if_fail(s, NULL);
if (!s->db) {
return NULL;
}
char foo[32];
swi = getswi(s, swi);
snprintf(foo, sizeof(foo), "0x%x.%d", swi, num);
return sdb_const_get(s->db, foo, 0);
}
static bool callback_list(void *u, const char *k, const char *v) {
RzList *list = (RzList *)u;
if (!strchr(k, '.')) {
RzSyscallItem *si = rz_syscall_item_new_from_string(k, v);
if (!si) {
return true;
}
if (!strchr(si->name, '.')) {
rz_list_append(list, si);
} else {
rz_syscall_item_free(si);
}
}
return true; // continue loop
}
RZ_API RzList /**/ *rz_syscall_list(RzSyscall *s) {
rz_return_val_if_fail(s, NULL);
if (!s->db) {
return NULL;
}
RzList *list = rz_list_newf((RzListFree)rz_syscall_item_free);
sdb_foreach(s->db, callback_list, list);
return list;
}
/**
* \brief Searches the sysregs SDB database inside librz/reg/d for the type (mmio/reg) and
* returns its value as a string
*
* \param s reference to RzSyscall
* \param type reference to the type of key: mmio/reg
* \param port reference to the io port
*/
RZ_API const char *rz_sysreg_get(RzSyscall *s, const char *type, ut64 port) {
rz_return_val_if_fail(s, NULL);
if (!s->srdb) {
return NULL;
}
RzSysregItem *item = ht_up_find(s->srdb->port, port, NULL);
if (item && !strcmp(item->type, type)) {
return item->comment;
}
return NULL;
}
rizin-0.7.4/librz/syscall/README.md 0000664 0001750 0001750 00000000000 14731035230 016256 0 ustar sophie sophie rizin-0.7.4/librz/syscall/d2/ 0000775 0001750 0001750 00000000000 14731035230 015316 5 ustar sophie sophie rizin-0.7.4/librz/syscall/d2/gen.sh 0000775 0001750 0001750 00000000132 14731035230 016422 0 ustar sophie sophie #!/bin/sh
awk -F '(=|,)' '{
print $2"."$3"="$1
# exit=0x80,1,1,i
print $1"="$2","$3
}'
rizin-0.7.4/librz/syscall/d2/x86-16.txt 0000664 0001750 0001750 00000002145 14731035230 016732 0 ustar sophie sophie from bochs: http://bochs.sourceforge.net/techspec/PORTS.LST
0x0000-0x001F The first legacy DMA controller, often used for transfers to floppies.
0x0020-0x0021 The first Programmable Interrupt Controller
0x0022-0x0023 Access to the Model-Specific Registers of Cyrix processors.
0x0040-0x0047 The PIT (Programmable Interval Timer)
0x0060-0x0064 The "8042" PS/2 Controller or its predecessors, dealing with keyboards and mice.
0x0070-0x0071 The CMOS and RTC registers
0x0080-0x008F The DMA (Page registers)
0x0092 The location of the fast A20 gate register
0x00A0-0x00A1 The second PIC
0x00C0-0x00DF The second DMA controller, often used for soundblasters
0x00E9 Home of the Port E9 Hack. Used on some emulators to directly send text to the hosts' console.
0x0170-0x0177 The secondary ATA harddisk controller.
0x01F0-0x01F7 The primary ATA harddisk controller.
0x0278-0x027A Parallel port
0x02F8-0x02FF Second serial port
0x03B0-0x03DF The range used for the IBM VGA, its direct predecessors, as well as any modern video card in legacy mode.
0x03F0-0x03F7 Floppy disk controller
0x03F8-0x03FF First serial port
rizin-0.7.4/librz/type/ 0000775 0001750 0001750 00000000000 14731035230 014320 5 ustar sophie sophie rizin-0.7.4/librz/type/function.c 0000664 0001750 0001750 00000043414 14731035230 016317 0 ustar sophie sophie // SPDX-FileCopyrightText: 2013-2020 pancake
// SPDX-FileCopyrightText: 2013-2020 oddcoder
// SPDX-FileCopyrightText: 2013-2020 sivaramaaa
// SPDX-FileCopyrightText: 2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
/**
* \brief Creates a new RzCallable type
*
* \param name Name of the callable type
* \param type A return type of the callable type
*/
RZ_API RZ_OWN RzCallable *rz_type_callable_new(RZ_NULLABLE const char *name) {
RzCallable *callable = RZ_NEW0(RzCallable);
if (!callable) {
return NULL;
}
callable->ret = NULL;
callable->name = name ? strdup(name) : NULL;
callable->args = rz_pvector_new((RzPVectorFree)rz_type_callable_arg_free);
return callable;
}
/**
* \brief Creates an exact clone of the RzCallable type
*
* \param callable RzCallable instance to clone
*/
RZ_API RZ_OWN RzCallable *rz_type_callable_clone(RZ_BORROW RZ_NONNULL const RzCallable *callable) {
rz_return_val_if_fail(callable, NULL);
RzCallable *newcallable = RZ_NEWCOPY(RzCallable, callable);
if (!newcallable) {
return NULL;
}
newcallable->ret = callable->ret ? rz_type_clone(callable->ret) : NULL;
newcallable->name = callable->name ? strdup(callable->name) : NULL;
newcallable->args = rz_pvector_new((RzPVectorFree)rz_type_callable_arg_free);
void **it;
rz_pvector_foreach (callable->args, it) {
RzCallableArg *arg = *it;
rz_pvector_push(newcallable->args, rz_type_callable_arg_clone(arg));
}
return newcallable;
}
/**
* \brief Frees the RzCallable
*
* \param callable RzCallable type
*/
RZ_API void rz_type_callable_free(RZ_NONNULL RzCallable *callable) {
rz_type_free(callable->ret);
rz_pvector_free(callable->args);
free(callable->name);
free(callable);
}
/**
* \brief Creates a new RzCallableArg given the name and type
*
* \param typedb RzTypeDB instance
* \param name Name of the argument
* \param type RzType type of the argument
*/
RZ_API RZ_OWN RzCallableArg *rz_type_callable_arg_new(RzTypeDB *typedb, RZ_NONNULL const char *name, RZ_OWN RZ_NONNULL RzType *type) {
rz_return_val_if_fail(typedb && name && type, NULL);
RzCallableArg *arg = RZ_NEW0(RzCallableArg);
if (!arg) {
return NULL;
}
arg->name = strdup(name);
arg->type = type;
return arg;
}
/**
* \brief Creates am exact clone of RzCallableArg
*
* \param arg RzCallable argument pointer
*/
RZ_API RZ_OWN RzCallableArg *rz_type_callable_arg_clone(RZ_BORROW RZ_NONNULL const RzCallableArg *arg) {
rz_return_val_if_fail(arg, NULL);
RzCallableArg *newarg = RZ_NEW0(RzCallableArg);
if (!newarg) {
return NULL;
}
newarg->name = strdup(arg->name);
newarg->type = rz_type_clone(arg->type);
return newarg;
}
/**
* \brief Frees the RzCallableArg
*
* \param arg RzCallableArg instance
*/
RZ_API void rz_type_callable_arg_free(RzCallableArg *arg) {
if (!arg) {
return;
}
free(arg->name);
rz_type_free(arg->type);
free(arg);
}
/**
* \brief Adds a new argument to the RzCallable
*
* \param callable RzCallable instance
* \param arg Argument to add
*/
RZ_API bool rz_type_callable_arg_add(RZ_NONNULL RzCallable *callable, RZ_OWN RZ_NONNULL RzCallableArg *arg) {
rz_return_val_if_fail(callable && arg, false);
rz_pvector_push(callable->args, arg);
return true;
}
// Function prototypes api
/**
* \brief Creates a new RzCallable type
*
* \param typedb RzTypeDB instance
* \param name Name of the callable type
* \param type A return type of the callable type
*/
RZ_API RZ_OWN RzCallable *rz_type_func_new(RzTypeDB *typedb, RZ_NONNULL const char *name, RZ_OWN RZ_NULLABLE RzType *type) {
rz_return_val_if_fail(typedb && name, NULL);
RzCallable *callable = rz_type_callable_new(name);
if (!callable) {
return NULL;
}
callable->ret = type;
return callable;
}
/**
* \brief Stores RzCallable type in the types database
*
* \param typedb Type Database instance
* \param callable RzCallable type to save
*/
RZ_API bool rz_type_func_save(RzTypeDB *typedb, RZ_NONNULL RzCallable *callable) {
rz_return_val_if_fail(typedb && callable && callable->name, false);
if (rz_type_func_exist(typedb, callable->name)) {
return false;
}
ht_pp_insert(typedb->callables, callable->name, callable);
return true;
}
/**
* \brief Update RzCallable type in the types database
*
* \param typedb Type Database instance
* \param callable RzCallable type to save
*/
RZ_API bool rz_type_func_update(RzTypeDB *typedb, RZ_NONNULL RzCallable *callable) {
rz_return_val_if_fail(typedb && callable && callable->name, false);
if (!ht_pp_update(typedb->callables, callable->name, (void *)callable)) {
rz_type_callable_free(callable);
return false;
}
return true;
}
/**
* \brief Returns the RzCallable from the database by name
*
* \param typedb Type Database instance
* \param name RzCallable (function) name to search
*/
RZ_API RZ_BORROW RzCallable *rz_type_func_get(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, NULL);
bool found = false;
RzCallable *callable = ht_pp_find(typedb->callables, name, &found);
if (!found || !callable) {
RZ_LOG_DEBUG("Cannot find function type \"%s\"\n", name);
return NULL;
}
return callable;
}
/**
* \brief Removes RzCallable type from the types database
*
* \param typedb Type Database instance
* \param name Name of the callable to search
*/
RZ_API bool rz_type_func_delete(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, false);
ht_pp_delete(typedb->callables, name);
return true;
}
static void callables_ht_free(HtPPKv *kv) {
rz_type_callable_free(kv->value);
}
/**
* \brief Removes all RzCallable types
*/
RZ_API void rz_type_func_delete_all(RzTypeDB *typedb) {
ht_pp_free(typedb->callables);
typedb->callables = ht_pp_new(NULL, callables_ht_free, NULL);
}
/**
* \brief Checks if the RzCallable type exists in the database given the name
*
* \param typedb Type Database instance
* \param name Name of the callable to search
*/
RZ_API bool rz_type_func_exist(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, false);
bool found = false;
return ht_pp_find(typedb->callables, name, &found) && found;
}
/**
* \brief Searches for the RzCallable type in types database and returns return type
*
* \param typedb Type Database instance
* \param name Name of the callable to search
*/
RZ_API RZ_BORROW RzType *rz_type_func_ret(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, NULL);
RzCallable *callable = rz_type_func_get(typedb, name);
if (!callable) {
return NULL;
}
return callable->ret;
}
/**
* \brief Searches for the RzCallable type in types database and returns calling convention
*
* \param typedb Type Database instance
* \param name Name of the callable to search
*/
RZ_API RZ_BORROW const char *rz_type_func_cc(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, NULL);
RzCallable *callable = rz_type_func_get(typedb, name);
if (!callable) {
return NULL;
}
return callable->cc;
}
/**
* \brief Searches for the RzCallable type in types database and set the calling convention
*
* \param typedb Type Database instance
* \param name Name of the callable to search
* \param name Name of the calling convention to set
*/
RZ_API bool rz_type_func_cc_set(RzTypeDB *typedb, const char *name, const char *cc) {
rz_return_val_if_fail(typedb && name, false);
RzCallable *callable = rz_type_func_get(typedb, name);
if (!callable) {
return false;
}
callable->cc = strdup(cc);
return true;
}
/**
* \brief Searches for the RzCallable type in types database and returns arguments' count
*
* \param typedb Type Database instance
* \param name Name of the callable to search
*/
RZ_API int rz_type_func_args_count(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, 0);
RzCallable *callable = rz_type_func_get(typedb, name);
if (!callable) {
return -1;
}
return rz_pvector_len(callable->args);
}
/**
* \brief Searches for the RzCallable type in types database and returns argument type
*
* \param typedb Type Database instance
* \param name Name of the callable to search
* \param i Index of the argument go get type of
*/
RZ_API RZ_BORROW RzType *rz_type_func_args_type(RzTypeDB *typedb, RZ_NONNULL const char *name, int i) {
rz_return_val_if_fail(typedb && name, NULL);
RzCallable *callable = rz_type_func_get(typedb, name);
if (!callable) {
return NULL;
}
if (i >= rz_pvector_len(callable->args)) {
return NULL;
}
RzCallableArg *arg = *rz_pvector_index_ptr(callable->args, i);
if (!arg) {
rz_warn_if_reached(); // should not happen in the types database
return NULL;
}
return arg->type;
}
/**
* \brief Searches for the RzCallable type in types database and returns argument name
*
* \param typedb Type Database instance
* \param name Name of the callable to search
* \param i Index of the argument go get type of
*/
RZ_API RZ_BORROW const char *rz_type_func_args_name(RzTypeDB *typedb, RZ_NONNULL const char *name, int i) {
rz_return_val_if_fail(typedb && name, NULL);
RzCallable *callable = rz_type_func_get(typedb, name);
if (!callable) {
return NULL;
}
if (i >= rz_pvector_len(callable->args)) {
return NULL;
}
RzCallableArg *arg = *rz_pvector_index_ptr(callable->args, i);
if (!arg) {
rz_warn_if_reached(); // should not happen in the types database
return NULL;
}
return arg->name;
}
/**
* \brief Adds a new argument to the RzCallable type at the end of the arguments vector
*
* \param typedb Type Database instance
* \param func_name Name of the callable to search
* \param arg_name Name of the new argument
* \param arg_type RzType type of the new argument
*/
RZ_API bool rz_type_func_arg_add(RzTypeDB *typedb, RZ_NONNULL const char *func_name, RZ_NONNULL const char *arg_name, RZ_OWN RZ_NONNULL RzType *arg_type) {
rz_return_val_if_fail(typedb && func_name, false);
RzCallable *callable = rz_type_func_get(typedb, func_name);
if (!callable) {
return false;
}
RzCallableArg *arg = rz_type_callable_arg_new(typedb, arg_name, arg_type);
if (!arg) {
return false;
}
rz_pvector_push(callable->args, arg);
return true;
}
/**
* \brief Sets the new return type for the RzCallable
*
* \param typedb Type Database instance
* \param name Name of the callable to search
* \param type RzType return type
*/
RZ_API bool rz_type_func_ret_set(RzTypeDB *typedb, const char *name, RZ_BORROW RZ_NONNULL RzType *type) {
rz_return_val_if_fail(typedb && name && type, false);
RzCallable *callable = rz_type_func_get(typedb, name);
if (!callable) {
return false;
}
rz_type_free(callable->ret);
callable->ret = rz_type_clone(type);
return true;
}
/**
* \brief Checks if the RzType is the pointer to the RzCallable
*
* \param typedb Types Database instance
* \param type RzType
*/
RZ_API bool rz_type_is_callable(RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
return type->kind == RZ_TYPE_KIND_CALLABLE;
}
/**
* \brief Checks if the RzType is the pointer to the RzCallable
*
* \param typedb Types Database instance
* \param type RzType
*/
RZ_API bool rz_type_is_callable_ptr(RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
if (type->kind != RZ_TYPE_KIND_POINTER) {
return false;
}
if (type->pointer.type->kind == RZ_TYPE_KIND_CALLABLE) {
return true;
} else if (type->pointer.type->kind == RZ_TYPE_KIND_POINTER) {
return rz_type_is_callable_ptr(type->pointer.type);
}
return false;
}
/**
* \brief Checks if the RzType is the nested pointer to the RzCallable
*
* For example it could be one of those:
* - int (*func)(int a, char *b)
* - int (**func)(int a, char *b)
* - int (****func)(int a, char *b)
*
* \param typedb Types Database instance
* \param type RzType
*/
RZ_API bool rz_type_is_callable_ptr_nested(RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
if (type->kind != RZ_TYPE_KIND_POINTER) {
return false;
}
// There should not exist pointers to the empty types
RzType *ptr = type->pointer.type;
rz_return_val_if_fail(ptr, false);
if (ptr->kind == RZ_TYPE_KIND_POINTER) {
return rz_type_is_callable_ptr_nested(ptr);
}
return ptr->kind == RZ_TYPE_KIND_CALLABLE;
}
static const RzCallable *callable_ptr_unwrap(RZ_NONNULL const RzType *type, size_t *acc) {
rz_return_val_if_fail(type && acc, NULL);
if (type->kind == RZ_TYPE_KIND_POINTER) {
*acc = *acc + 1;
return callable_ptr_unwrap(type->pointer.type, acc);
}
return type->kind == RZ_TYPE_KIND_CALLABLE ? type->callable : NULL;
}
static inline char *callable_name_or_ptr(RZ_NONNULL const RzCallable *callable, size_t ptr_depth) {
if (ptr_depth > 0) {
// Due to the portability issues with other solutions we use this hack to repeat the '*' character
return rz_str_newf("(%.*s%s)", (int)ptr_depth, "****************", rz_str_get(callable->name));
} else {
return strdup(rz_str_get(callable->name));
}
}
static bool callable_as_string(RzStrBuf *buf, const RzTypeDB *typedb, RZ_NONNULL const RzCallable *callable, size_t ptr_depth) {
rz_return_val_if_fail(buf && typedb && callable, false);
if (callable->noret) {
rz_strbuf_append(buf, "__attribute__((noreturn)) ");
}
char *ret_str = callable->ret ? rz_type_as_string(typedb, callable->ret) : NULL;
char *callable_name = callable_name_or_ptr(callable, ptr_depth);
rz_strbuf_appendf(buf, "%s %s(", ret_str ? ret_str : "void", callable_name);
free(ret_str);
free(callable_name);
void **it;
bool first = true;
rz_pvector_foreach (callable->args, it) {
RzCallableArg *arg = *it;
if (arg) {
char *argstr = rz_type_identifier_declaration_as_string(typedb, arg->type, rz_str_get(arg->name));
const char *comma = first ? "" : ", ";
rz_strbuf_appendf(buf, "%s%s", comma, argstr);
first = false;
free(argstr);
}
}
if (callable->has_unspecified_parameters) {
if (rz_pvector_len(callable->args) >= 1) {
rz_strbuf_append(buf, ", ");
}
rz_strbuf_append(buf, "...");
}
rz_strbuf_append(buf, ")");
return true;
}
/**
* \brief Returns the callable pointer C representation
*
* \param typedb Types Database instance
* \param callable RzCallable instance
*/
RZ_API RZ_OWN char *rz_type_callable_ptr_as_string(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(typedb && type, NULL);
rz_return_val_if_fail(type->kind == RZ_TYPE_KIND_POINTER, NULL);
size_t ptr_depth = 0;
const RzCallable *callable = callable_ptr_unwrap(type, &ptr_depth);
if (!callable) {
return NULL;
}
RzStrBuf *buf = rz_strbuf_new("");
if (!callable_as_string(buf, typedb, callable, ptr_depth)) {
rz_strbuf_free(buf);
return NULL;
}
return rz_strbuf_drain(buf);
}
/**
* \brief Returns the callable C representation
*
* \param typedb Types Database instance
* \param callable RzCallable instance
*/
RZ_API RZ_OWN char *rz_type_callable_as_string(const RzTypeDB *typedb, RZ_NONNULL const RzCallable *callable) {
rz_return_val_if_fail(typedb && callable, NULL);
RzStrBuf *buf = rz_strbuf_new("");
if (!callable_as_string(buf, typedb, callable, 0)) {
rz_strbuf_free(buf);
return NULL;
}
return rz_strbuf_drain(buf);
}
/**
* \brief Checks if the RzCallable type is defined as "noreturn"
*
* \param typedb Types Database instance
* \param name Name of the RzCallable type
*/
RZ_API bool rz_type_func_is_noreturn(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, false);
RzCallable *callable = rz_type_func_get(typedb, name);
if (!callable) {
return false;
}
return callable->noret;
}
/**
* \brief Adds the "noreturn" attribute to the RzCallable type
*
* \param typedb Types Database instance
* \param name Name of the RzCallable type
*/
RZ_API bool rz_type_func_noreturn_add(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, false);
// If the function exists with the specified name already, we set the noreturn flag for it
RzCallable *callable = rz_type_func_get(typedb, name);
if (callable) {
callable->noret = true;
} else {
// If it doesn't - we create a new dummy RzCallable for it
// The return type is default and no arguments
callable = rz_type_func_new(typedb, name, NULL);
if (!callable) {
return false;
}
callable->noret = true;
rz_type_func_save(typedb, callable);
}
return true;
}
/**
* \brief Drops the "noreturn" attribute from the RzCallable type
*
* \param typedb Types Database instance
* \param name Name of the RzCallable type
*/
RZ_API bool rz_type_func_noreturn_drop(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, false);
RzCallable *callable = rz_type_func_get(typedb, name);
if (!callable) {
return false;
}
callable->noret = false;
return true;
}
// Listing function types
static bool function_names_collect_cb(void *user, const void *k, const void *v) {
RzList *l = (RzList *)user;
RzCallable *callable = (RzCallable *)v;
rz_list_append(l, strdup(callable->name));
return true;
}
/**
* \brief Returns the list of all function type names
*
* \param typedb Types Database instance
*/
RZ_API RZ_OWN RzList /**/ *rz_type_function_names(RzTypeDB *typedb) {
rz_return_val_if_fail(typedb, NULL);
RzList *result = rz_list_newf(free);
ht_pp_foreach(typedb->callables, function_names_collect_cb, result);
return result;
}
static bool noreturn_function_names_collect_cb(void *user, const void *k, const void *v) {
RzList *l = (RzList *)user;
RzCallable *callable = (RzCallable *)v;
if (callable->noret) {
rz_list_append(l, strdup(callable->name));
}
return true;
}
/**
* \brief Returns the list of all noreturn function type names
*
* \param typedb Types Database instance
*/
RZ_API RZ_OWN RzList /**/ *rz_type_noreturn_function_names(RzTypeDB *typedb) {
rz_return_val_if_fail(typedb, NULL);
RzList *noretl = rz_list_newf(free);
ht_pp_foreach(typedb->callables, noreturn_function_names_collect_cb, noretl);
return noretl;
}
rizin-0.7.4/librz/type/format.c 0000664 0001750 0001750 00000250073 14731035230 015763 0 ustar sophie sophie // SPDX-FileCopyrightText: 2007-2020 pancake
// SPDX-FileCopyrightText: 2007-2020 Skia
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#define NOPTR 0
#define PTRSEEK 1
#define PTRBACK 2
#define NULLPTR 3
#define STRUCTPTR 100
#define NESTEDSTRUCT 1
#define STRUCTFLAG 10000
#define NESTDEPTH 14
#define ARRAYINDEX_COEF 10000
#define MUSTSEE (mode & RZ_PRINT_MUSTSEE && mode & RZ_PRINT_ISFIELD && !(mode & RZ_PRINT_JSON))
#define ISQUIET (mode & RZ_PRINT_QUIET)
#define MUSTSET (mode & RZ_PRINT_MUSTSET && mode & RZ_PRINT_ISFIELD && setval)
#define SEEVALUE (mode & RZ_PRINT_VALUE)
#define MUSTSEEJSON (mode & RZ_PRINT_JSON && mode & RZ_PRINT_ISFIELD)
#define MUSTSEESTRUCT (mode & RZ_PRINT_STRUCT)
// this define is used as a way to acknowledge when updateAddr should take len
// as real len of the buffer
#define THRESHOLD (-4444)
// TODO REWRITE THIS IS BECOMING A NIGHTMARE
static float updateAddr(const ut8 *buf, int len, int endian, ut64 *addr, ut64 *addr64, bool read_float) {
float f = 0.0;
// assert sizeof (float) == sizeof (ut32))
// XXX 999 is used as an implicit buffer size, we should pass the buffer size to every function too, otherwise this code will give us some problems
if (len >= THRESHOLD - 7 && len < THRESHOLD) {
len = len + THRESHOLD; // get the real len to avoid oob
} else {
len = 999;
}
if (len < 1) {
return 0;
}
if (read_float && len >= sizeof(float)) {
f = rz_read_ble_float(buf, endian);
}
if (addr && len > 3) {
ut32 tmpaddr = rz_read_ble32(buf, endian);
*addr = (ut64)tmpaddr;
}
if (addr64 && len > 7) {
*addr64 = rz_read_ble64(buf, endian);
}
return f;
}
static int rz_get_size(RzNum *num, ut8 *buf, int endian, const char *s) {
int len = strlen(s);
if (s[0] == '*' && len >= 4) { // value pointed by the address
ut64 addr;
int offset = (int)rz_num_math(num, s + 1);
(void)updateAddr(buf + offset, 999, endian, &addr, NULL, false);
return addr;
}
// flag handling doesnt seems to work here
return rz_num_math(num, s);
}
static void rz_type_format_u128(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
ut64 low = rz_read_ble64(buf, endian);
ut64 hig = rz_read_ble64(buf + 8, endian);
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "\"");
} else if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = (uint128_t)", seeki);
}
if (endian) {
rz_strbuf_appendf(outbuf, "0x%016" PFMT64x "", low);
rz_strbuf_appendf(outbuf, "%016" PFMT64x, hig);
} else {
rz_strbuf_appendf(outbuf, "0x%016" PFMT64x "", hig);
rz_strbuf_appendf(outbuf, "%016" PFMT64x, low);
}
if (MUSTSEEJSON) {
const char *end = endian ? "big" : "little";
rz_strbuf_appendf(outbuf, "\",\"endian\":\"%s\",\"ctype\":\"uint128_t\"}", end);
}
}
static void rz_type_format_quadword(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
ut64 addr64;
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
updateAddr(buf + i, size - i, endian, NULL, &addr64, false);
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "wv8 %s @ 0x%08" PFMT64x "\n", setval, seeki + ((elem >= 0) ? elem * 8 : 0));
} else if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = (qword)",
seeki + ((elem >= 0) ? elem * 8 : 0));
}
if (size == -1) {
if (addr64 == UT32_MAX || ((st64)addr64 < 0 && (st64)addr64 > -4096)) {
rz_strbuf_appendf(outbuf, "%d", (int)(addr64));
} else {
rz_strbuf_appendf(outbuf, "0x%016" PFMT64x, addr64);
}
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
updateAddr(buf + i, size - i, endian, NULL, &addr64, false);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "0x%016" PFMT64x, addr64);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 8;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
} else if (MUSTSEEJSON || MUSTSEESTRUCT) {
if (size == -1) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr64);
} else {
rz_strbuf_append(outbuf, "[ ");
while (size--) {
updateAddr(buf + i, size - i, endian, NULL, &addr64, false);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr64);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 8;
}
rz_strbuf_append(outbuf, " ]");
}
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "}");
}
}
}
static void rz_type_format_byte(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "\"w %s\" @ 0x%08" PFMT64x "\n", setval, seeki + ((elem >= 0) ? elem : 0));
} else if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki + ((elem >= 0) ? elem : 0));
}
if (size == -1) {
rz_strbuf_appendf(outbuf, "0x%02x", buf[i]);
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "0x%02x", buf[i]);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i++;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
} else if (MUSTSEEJSON || MUSTSEESTRUCT) {
if (size == -1) {
rz_strbuf_appendf(outbuf, "%d", buf[i]);
} else {
rz_strbuf_append(outbuf, "[ ");
const char *comma = "";
while (size--) {
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%s%d", comma, buf[i]);
comma = ",";
if (elem == 0) {
elem = -2;
}
}
if (elem > -1) {
elem--;
}
i++;
}
rz_strbuf_append(outbuf, " ]");
}
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "}");
}
}
}
// FIXME: Port to the PJ API
// Return number of consumed bytes
static int rz_type_format_uleb(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
int elem = -1;
int s = 0, offset = 0;
ut64 value = 0;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
if (MUSTSET) {
ut8 *tmp;
char *nbr;
do {
rz_uleb128_decode(buf + i, &s, &value);
i += s;
offset += s;
} while (elem--);
tmp = (ut8 *)rz_uleb128_encode(rz_num_math(NULL, setval), &s);
nbr = rz_hex_bin2strdup(tmp, s);
rz_strbuf_appendf(outbuf, "wx %s @ 0x%08" PFMT64x "\n", nbr, seeki + offset - s);
free(tmp);
free(nbr);
} else if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki);
}
if (size == -1) {
rz_uleb128_decode(buf + i, &offset, &value);
rz_strbuf_appendf(outbuf, "%" PFMT64d, value);
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
if (elem == -1 || elem == 0) {
rz_uleb128_decode(buf + i, &s, &value);
i += s;
offset += s;
rz_strbuf_appendf(outbuf, "%" PFMT64d, value);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
} else if (MUSTSEEJSON || MUSTSEESTRUCT) {
if (size == -1) {
rz_uleb128_decode(buf + i, &offset, &value);
rz_strbuf_appendf(outbuf, "\"%" PFMT64d "\"", value);
} else {
rz_strbuf_append(outbuf, "[ ");
while (size--) {
if (elem == -1 || elem == 0) {
rz_uleb128_decode(buf + i, &s, &value);
i += s;
offset += s;
rz_strbuf_appendf(outbuf, "\"%" PFMT64d "\"", value);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
}
rz_strbuf_append(outbuf, " ]");
}
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "}");
}
}
return offset;
}
static void rz_type_format_char(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "\"w %s\" @ 0x%08" PFMT64x "\n", setval, seeki + ((elem >= 0) ? elem : 0));
} else if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki + ((elem >= 0) ? elem * 2 : 0)); // XXX:: shouldn't it be elem*1??
}
if (size == -1) {
rz_strbuf_appendf(outbuf, "'%c'", IS_PRINTABLE(buf[i]) ? buf[i] : '.');
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "'%c'", IS_PRINTABLE(buf[i]) ? buf[i] : '.');
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i++;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
} else if (MUSTSEEJSON || MUSTSEESTRUCT) {
if (size == -1) {
rz_strbuf_appendf(outbuf, "\"%c\"", IS_PRINTABLE(buf[i]) ? buf[i] : '.');
} else {
rz_strbuf_append(outbuf, "[ ");
while (size--) {
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "\"%c\"", IS_PRINTABLE(buf[i]) ? buf[i] : '.');
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i++;
}
rz_strbuf_append(outbuf, " ]");
}
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "}");
}
}
}
static void rz_type_format_decchar(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "\"w %s\" @ 0x%08" PFMT64x "\n", setval, seeki + ((elem >= 0) ? elem : 0));
} else if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki + ((elem >= 0) ? elem : 0));
}
if (size == -1) {
rz_strbuf_appendf(outbuf, "%d", buf[i]);
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%d", buf[i]);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_appendf(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i++;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
} else if (MUSTSEEJSON || MUSTSEESTRUCT) {
if (size == -1) {
rz_strbuf_appendf(outbuf, "\"%d\"", buf[i]);
} else {
rz_strbuf_append(outbuf, "[ ");
while (size--) {
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "\"%d\"", buf[i]);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_appendf(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i++;
}
rz_strbuf_append(outbuf, " ]");
}
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "}");
}
}
}
static int rz_type_format_string(const RzTypeDB *typedb, RzStrBuf *outbuf, ut64 seeki, ut64 addr64, ut64 addr, int is64, int mode) {
ut8 buffer[255];
buffer[0] = 0;
const ut64 at = (is64 == 1) ? addr64 : (ut64)addr;
int res = typedb->iob.read_at(typedb->iob.io, at, buffer, sizeof(buffer) - 8);
if (MUSTSEEJSON) {
char *encstr = rz_str_utf16_encode((const char *)buffer, -1);
if (encstr) {
rz_strbuf_appendf(outbuf, "%" PFMT64d ",\"string\":\"%s\"}", seeki, encstr);
free(encstr);
}
} else if (MUSTSEESTRUCT) {
char *encstr = rz_str_utf16_encode((const char *)buffer, -1);
if (encstr) {
rz_strbuf_appendf(outbuf, "\"%s\"", encstr);
free(encstr);
}
} else if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki);
}
if (!SEEVALUE) {
if (ISQUIET) {
if (addr == 0LL) {
rz_strbuf_append(outbuf, "NULL");
} else if (addr == UT32_MAX || addr == UT64_MAX) {
rz_strbuf_append(outbuf, "-1");
} else {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " ", addr);
}
} else {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " -> 0x%08" PFMT64x " ", seeki, addr);
}
}
if (res > 0 && buffer[0] != 0xff && buffer[1] != 0xff) {
rz_strbuf_appendf(outbuf, "\"%s\"", buffer);
}
}
return 0;
}
static void rz_type_format_time(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
ut64 addr;
struct tm timestruct;
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "wv4 %s @ 0x%08" PFMT64x "\n", setval, seeki + ((elem >= 0) ? elem * 4 : 0));
} else if (MUSTSEE) {
char *timestr = malloc(ASCTIME_BUF_MINLEN);
if (!timestr) {
return;
}
rz_asctime_r(rz_gmtime_r((time_t *)&addr, ×truct), timestr);
*(timestr + 24) = '\0';
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki + ((elem >= 0) ? elem * 4 : 0));
}
if (size == -1) {
rz_strbuf_appendf(outbuf, "%s", timestr);
} else {
if (!SEEVALUE) {
rz_strbuf_appendf(outbuf, "[ ");
}
while (size--) {
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
rz_asctime_r(rz_gmtime_r((time_t *)&addr, ×truct), timestr);
*(timestr + 24) = '\0';
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%s", timestr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_appendf(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 4;
}
if (!SEEVALUE) {
rz_strbuf_appendf(outbuf, " ]");
}
}
free(timestr);
} else if (MUSTSEEJSON || MUSTSEESTRUCT) {
char *timestr = malloc(ASCTIME_BUF_MINLEN);
if (!timestr) {
return;
}
rz_asctime_r(rz_gmtime_r((time_t *)&addr, ×truct), timestr);
*(timestr + 24) = '\0';
if (size == -1) {
rz_strbuf_appendf(outbuf, "\"%s\"", timestr);
} else {
rz_strbuf_append(outbuf, "[ ");
while (size--) {
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
rz_asctime_r(rz_gmtime_r((time_t *)&addr, ×truct), timestr);
*(timestr + 24) = '\0';
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "\"%s\"", timestr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 4;
}
rz_strbuf_append(outbuf, " ]");
}
free(timestr);
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "}");
}
}
}
// TODO: support unsigned int?
static void rz_type_format_hex(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
ut64 addr = 0;
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "wv4 %s @ 0x%08" PFMT64x "\n", setval, seeki + ((elem >= 0) ? elem * 4 : 0));
} else if ((mode & RZ_PRINT_DOT) || MUSTSEESTRUCT) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
} else if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki + ((elem >= 0) ? elem * 4 : 0));
}
if (size == -1) {
if (addr == UT64_MAX || addr == UT32_MAX) {
rz_strbuf_append(outbuf, "-1");
} else {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
}
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (elem == -1 || elem == 0) {
if (ISQUIET) {
if (addr == UT64_MAX || addr == UT32_MAX) {
rz_strbuf_append(outbuf, "-1");
} else {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
}
} else {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
}
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 4;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
} else if (MUSTSEEJSON) {
if (size == -1) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
} else {
rz_strbuf_append(outbuf, "[ ");
while (size--) {
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 4;
}
rz_strbuf_append(outbuf, " ]");
}
rz_strbuf_append(outbuf, "}");
}
}
static void rz_type_format_int(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
ut64 addr;
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "wv4 %s @ %" PFMT64d "\n", setval, seeki + ((elem >= 0) ? elem * 4 : 0));
} else if ((mode & RZ_PRINT_DOT) || MUSTSEESTRUCT) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x, addr);
} else if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki + ((elem >= 0) ? elem * 4 : 0));
}
if (size == -1) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, (st64)(st32)addr);
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, (st64)(st32)addr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 4;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
} else if (MUSTSEEJSON) {
if (size == -1) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
} else {
rz_strbuf_append(outbuf, "[ ");
while (size--) {
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 4;
}
rz_strbuf_append(outbuf, " ]");
}
rz_strbuf_append(outbuf, "}");
}
}
/*
static int rz_type_format_disasm(const RzPrint *p, ut64 seeki, int size) {
ut64 prevseeki = seeki;
if (!p->disasm || !p->user) {
return 0;
}
size = RZ_MAX(1, size);
while (size-- > 0) {
seeki += p->disasm(p->user, seeki);
}
return seeki - prevseeki;
}
*/
static void rz_type_format_octal(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
ut64 addr = 0;
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "wv4 %s @ 0x%08" PFMT64x "\n", setval, seeki + ((elem >= 0) ? elem * 4 : 0));
} else if ((mode & RZ_PRINT_DOT) || MUSTSEESTRUCT) {
rz_strbuf_appendf(outbuf, "0%" PFMT64o, addr);
} else if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki + ((elem >= 0) ? elem * 4 : 0));
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "(octal) ");
}
if (size == -1) {
rz_strbuf_appendf(outbuf, " 0%08" PFMT64o, addr);
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "0%08" PFMT64o, addr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 4;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
} else if (MUSTSEEJSON) {
if (size == -1) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
} else {
rz_strbuf_append(outbuf, "[ ");
while (size--) {
updateAddr(buf, i, endian, &addr, NULL, false);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 4;
}
rz_strbuf_append(outbuf, " ]");
}
rz_strbuf_append(outbuf, "}");
}
}
static void rz_type_format_hexflag(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
ut64 addr = 0;
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "wv4 %s @ 0x%08" PFMT64x "\n", setval, seeki + ((elem >= 0) ? elem * 4 : 0));
} else if ((mode & RZ_PRINT_DOT) || MUSTSEESTRUCT) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x, addr & UT32_MAX);
} else if (MUSTSEE) {
ut32 addr32 = (ut32)addr;
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki + ((elem >= 0) ? elem * 4 : 0));
}
if (size == -1) {
if (ISQUIET && (addr32 == UT32_MAX)) {
rz_strbuf_append(outbuf, "-1");
} else {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x, (ut64)addr32);
}
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x, addr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 4;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
} else if (MUSTSEEJSON) {
if (size == -1) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
} else {
rz_strbuf_append(outbuf, "[ ");
while (size--) {
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ",");
}
if (elem > -1) {
elem--;
}
i += 4;
}
rz_strbuf_append(outbuf, " ]");
}
rz_strbuf_append(outbuf, "}");
}
}
static int rz_type_format_10bytes(const RzTypeDB *typedb, RzStrBuf *outbuf, int mode, const char *setval,
ut64 seeki, ut64 addr, ut8 *buf) {
ut8 buffer[255];
int j;
if (MUSTSET) {
rz_strbuf_append(outbuf, "echo pf B not yet implemented\n");
} else if (mode & RZ_PRINT_DOT) {
for (j = 0; j < 10; j++) {
rz_strbuf_appendf(outbuf, "%02x ", buf[j]);
}
} else if (MUSTSEE) {
typedb->iob.read_at(typedb->iob.io, (ut64)addr, buffer, 248);
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki);
}
for (j = 0; j < 10; j++) {
rz_strbuf_appendf(outbuf, "%02x ", buf[j]);
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ... (");
}
for (j = 0; j < 10; j++) {
if (!SEEVALUE) {
if (IS_PRINTABLE(buf[j])) {
rz_strbuf_appendf(outbuf, "%c", buf[j]);
} else {
rz_strbuf_append(outbuf, ".");
}
}
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, ")");
}
} else if (MUSTSEEJSON) {
typedb->iob.read_at(typedb->iob.io, (ut64)addr, buffer, 248);
rz_strbuf_appendf(outbuf, "[ %d", buf[0]);
j = 1;
for (; j < 10; j++) {
rz_strbuf_appendf(outbuf, ", %d", buf[j]);
}
rz_strbuf_append(outbuf, "]");
return 0;
}
return 0;
}
static int rz_type_format_hexpairs(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
int j;
size = (size == -1) ? 1 : size;
if (MUSTSET) {
rz_strbuf_append(outbuf, "echo pf X not yet implemented\n");
} else if (mode & RZ_PRINT_DOT) {
for (j = 0; j < size; j++) {
rz_strbuf_appendf(outbuf, "%02x", buf[i + j]);
}
} else if (MUSTSEE) {
size = (size < 1) ? 1 : size;
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki);
}
for (j = 0; j < size; j++) {
rz_strbuf_appendf(outbuf, "%02x ", buf[i + j]);
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ... (");
}
for (j = 0; j < size; j++) {
if (!SEEVALUE) {
if (IS_PRINTABLE(buf[j])) {
rz_strbuf_appendf(outbuf, "%c", buf[i + j]);
} else {
rz_strbuf_append(outbuf, ".");
}
}
}
rz_strbuf_append(outbuf, ")");
} else if (MUSTSEEJSON || MUSTSEESTRUCT) {
size = (size < 1) ? 1 : size;
rz_strbuf_appendf(outbuf, "[ %d", buf[0]);
j = 1;
for (; j < 10; j++) {
rz_strbuf_appendf(outbuf, ", %d", buf[j]);
}
rz_strbuf_append(outbuf, "]");
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "}");
}
return size;
}
return size;
}
static void rz_type_format_float(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
float val_f = 0.0f;
ut64 addr = 0;
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
val_f = updateAddr(buf + i, 999, endian, &addr, NULL, true);
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "wv4 %s @ 0x%08" PFMT64x "\n", setval,
seeki + ((elem >= 0) ? elem * 4 : 0));
} else if ((mode & RZ_PRINT_DOT) || MUSTSEESTRUCT) {
rz_strbuf_appendf(outbuf, "%.9g", val_f);
} else {
if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ",
seeki + ((elem >= 0) ? elem * 4 : 0));
}
}
if (size == -1) {
rz_strbuf_appendf(outbuf, "%.9g", val_f);
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
val_f = updateAddr(buf + i, 9999, endian, &addr, NULL, true);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%.9g", val_f);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 4;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "}");
}
}
}
static void rz_type_format_double(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
double val_f = 0.0;
ut64 addr = 0;
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
updateAddr(buf + i, 999, endian, &addr, NULL, false);
val_f = rz_read_at_ble_double(buf, i, endian);
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "wv8 %s @ 0x%08" PFMT64x "\n", setval,
seeki + ((elem >= 0) ? elem * 8 : 0));
} else if ((mode & RZ_PRINT_DOT) || MUSTSEESTRUCT) {
rz_strbuf_appendf(outbuf, "%.17g", val_f);
} else {
if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ",
seeki + ((elem >= 0) ? elem * 8 : 0));
}
}
if (size == -1) {
rz_strbuf_appendf(outbuf, "%.17g", val_f);
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
// XXX this 999 is scary
updateAddr(buf + i, 9999, endian, &addr, NULL, false);
val_f = rz_read_at_ble_double(buf, i, endian);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%.17g", val_f);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 8;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
if (MUSTSEEJSON) {
rz_strbuf_appendf(outbuf, "}");
}
}
}
static void rz_type_format_word(RzStrBuf *outbuf, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
ut64 addr;
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
addr = rz_read_ble16(buf + i, endian);
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "wv2 %s @ 0x%08" PFMT64x "\n", setval, seeki + ((elem >= 0) ? elem * 2 : 0));
} else if ((mode & RZ_PRINT_DOT) || MUSTSEESTRUCT) {
if (size == -1) {
rz_strbuf_appendf(outbuf, "0x%04" PFMT64x, addr);
}
while ((size -= 2) > 0) {
addr = rz_read_ble16(buf + i, endian);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ",");
}
if (elem > -1) {
elem--;
}
i += 2;
}
} else if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki + ((elem >= 0) ? elem * 2 : 0));
}
if (size == -1) {
rz_strbuf_appendf(outbuf, "0x%04" PFMT64x, addr);
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
addr = rz_read_ble16(buf + i, endian);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "0x%04" PFMT64x, addr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += 2;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
} else if (MUSTSEEJSON) {
if (size == -1) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
} else {
rz_strbuf_append(outbuf, "[ ");
while ((size -= 2) > 0) {
addr = rz_read_ble16(buf + i, endian);
if (elem == -1 || elem == 0) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, addr);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ",");
}
if (elem > -1) {
elem--;
}
i += 2;
}
rz_strbuf_append(outbuf, " ]");
}
rz_strbuf_append(outbuf, "}");
}
}
static void rz_type_byte_escape(const RzPrint *p, const char *src, char **dst, int dot_nl) {
rz_return_if_fail(p->strconv_mode);
RzStrEscOptions opt = { 0 };
opt.dot_nl = dot_nl;
opt.show_asciidot = !strcmp(p->strconv_mode, "asciidot");
opt.esc_bslash = p->esc_bslash;
rz_str_byte_escape(src, dst, &opt);
}
static void rz_type_format_nulltermstring(const RzTypeDB *typedb, RzPrint *p, RzStrBuf *outbuf, int len, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
if (!typedb->iob.is_valid_offset(typedb->iob.io, seeki, 1)) {
ut8 ch = 0xff;
// XXX there are some cases where the memory is there but is_valid_offset fails
if (typedb->iob.read_at(typedb->iob.io, seeki, &ch, 1) != 1 && ch != 0xff) {
rz_strbuf_append(outbuf, "-1");
return;
}
}
if (p->flags & RZ_PRINT_FLAGS_UNALLOC && !(typedb->iob.io->cached & RZ_PERM_R)) {
ut64 total_map_left = 0;
ut64 addr = seeki;
RzIOMap *map;
while (total_map_left < len && (map = typedb->iob.io->va ? typedb->iob.map_get(typedb->iob.io, addr) : typedb->iob.map_get_paddr(typedb->iob.io, addr)) && map->perm & RZ_PERM_R) {
if (!map->itv.size) {
total_map_left = addr == 0 ? UT64_MAX : UT64_MAX - addr + 1;
break;
}
total_map_left += map->itv.size - (addr - (typedb->iob.io->va ? map->itv.addr : map->delta));
addr += total_map_left;
}
if (total_map_left < len) {
len = total_map_left;
}
}
int str_len = rz_str_nlen((char *)buf + i, len - i);
bool overflow = (size == -1 || size > len - i) && str_len == len - i;
if (MUSTSET) {
int buflen = strlen((const char *)buf + seeki);
int vallen = strlen(setval);
char *ons, *newstring = ons = strdup(setval);
if ((newstring[0] == '\"' && newstring[vallen - 1] == '\"') || (newstring[0] == '\'' && newstring[vallen - 1] == '\'')) {
newstring[vallen - 1] = '\0';
newstring++;
vallen -= 2;
}
if (vallen > buflen) {
eprintf("Warning: new string is longer than previous one\n");
}
rz_strbuf_append(outbuf, "wx ");
for (i = 0; i < vallen; i++) {
if (i < vallen - 3 && newstring[i] == '\\' && newstring[i + 1] == 'x') {
rz_strbuf_appendf(outbuf, "%c%c", newstring[i + 2], newstring[i + 3]);
i += 3;
} else {
rz_strbuf_appendf(outbuf, "%2x", newstring[i]);
}
}
rz_strbuf_appendf(outbuf, " @ 0x%08" PFMT64x "\n", seeki);
free(ons);
} else if ((mode & RZ_PRINT_DOT) || MUSTSEESTRUCT) {
int j = i;
(MUSTSEESTRUCT) ? rz_strbuf_append(outbuf, "\"") : rz_strbuf_append(outbuf, "\\\"");
for (; j < len && ((size == -1 || size-- > 0) && buf[j]); j++) {
char ch = buf[j];
if (ch == '"') {
rz_strbuf_append(outbuf, "\\\"");
} else if (IS_PRINTABLE(ch)) {
rz_strbuf_appendf(outbuf, "%c", ch);
} else {
rz_strbuf_append(outbuf, ".");
}
}
(MUSTSEESTRUCT) ? rz_strbuf_append(outbuf, "\"") : rz_strbuf_append(outbuf, "\\\"");
} else if (MUSTSEE) {
int j = i;
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = %s", seeki, overflow ? "ovf " : "");
}
rz_strbuf_append(outbuf, "\"");
for (; j < len && ((size == -1 || size-- > 0) && buf[j]); j++) {
char esc_str[5] = { 0 };
char *ptr = esc_str;
rz_type_byte_escape(p, (char *)&buf[j], &ptr, false);
rz_strbuf_appendf(outbuf, "%s", esc_str);
}
rz_strbuf_append(outbuf, "\"");
} else if (MUSTSEEJSON) {
char *utf_encoded_buf = NULL;
rz_strbuf_append(outbuf, "\"");
utf_encoded_buf = rz_str_escape_utf8_for_json(
(char *)buf + i, size == -1 ? str_len : RZ_MIN(size, str_len));
if (utf_encoded_buf) {
rz_strbuf_appendf(outbuf, "%s", utf_encoded_buf);
free(utf_encoded_buf);
}
rz_strbuf_append(outbuf, "\"");
if (overflow) {
rz_strbuf_append(outbuf, ",\"overflow\":true");
}
rz_strbuf_append(outbuf, "}");
}
}
static void rz_type_format_nulltermwidestring(RzPrint *p, RzStrBuf *outbuf, const int len, int endian, int mode,
const char *setval, ut64 seeki, ut8 *buf, int i, int size) {
if (MUSTSET) {
int vallen = strlen(setval);
char *newstring, *ons;
newstring = ons = strdup(setval);
if ((newstring[0] == '\"' && newstring[vallen - 1] == '\"') || (newstring[0] == '\'' && newstring[vallen - 1] == '\'')) {
newstring[vallen - 1] = '\0';
newstring++;
vallen -= 2;
}
if (vallen > rz_wstr_clen((char *)(buf + seeki))) {
eprintf("Warning: new string is longer than previous one\n");
}
rz_strbuf_appendf(outbuf, "ww %s @ 0x%08" PFMT64x "\n", newstring, seeki);
free(ons);
} else if (MUSTSEE) {
int j = i;
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki);
}
for (; j < len && ((size == -1 || size-- > 0) && buf[j]); j += 2) {
if (IS_PRINTABLE(buf[j])) {
rz_strbuf_appendf(outbuf, "%c", buf[j]);
} else {
rz_strbuf_append(outbuf, ".");
}
}
} else if (MUSTSEEJSON) {
int j = i;
rz_strbuf_appendf(outbuf, "%" PFMT64d ",\"string\":\"", seeki);
for (; j < len && ((size == -1 || size-- > 0) && buf[j]); j += 2) {
if (IS_PRINTABLE(buf[j])) {
rz_strbuf_appendf(outbuf, "%c", buf[j]);
} else {
rz_strbuf_append(outbuf, ".");
}
}
rz_strbuf_append(outbuf, "\"}");
}
}
static void rz_type_format_bitfield(const RzTypeDB *typedb, RzStrBuf *outbuf, ut64 seeki, char *fmtname,
char *fieldname, ut64 addr, int mode, int size) {
char *bitfield = NULL;
addr &= (1ULL << (size * 8)) - 1;
if (MUSTSEE && !SEEVALUE) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki);
}
bitfield = rz_type_db_enum_get_bitfield(typedb, fmtname, addr);
if (bitfield && *bitfield) {
if (MUSTSEEJSON) {
rz_strbuf_appendf(outbuf, "\"%s\"}", bitfield);
} else if (MUSTSEE) {
rz_strbuf_appendf(outbuf, "%s (bitfield) = %s\n", fieldname, bitfield);
}
} else {
if (MUSTSEEJSON) {
rz_strbuf_appendf(outbuf, "\"`tb %s 0x%" PFMT64x "`\"}", fmtname, addr);
} else if (MUSTSEE) {
rz_strbuf_appendf(outbuf, "%s (bitfield) = `tb %s 0x%" PFMT64x "`\n",
fieldname, fmtname, addr);
}
}
free(bitfield);
}
static void rz_type_format_enum(const RzTypeDB *typedb, RzStrBuf *outbuf, ut64 seeki, char *fmtname,
char *fieldname, ut64 addr, int mode, int size) {
const char *enumvalue = NULL;
addr &= (1ULL << (size * 8)) - 1;
if (MUSTSEE && !SEEVALUE) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki);
}
enumvalue = rz_type_db_enum_member_by_val(typedb, fmtname, addr);
if (enumvalue && *enumvalue) {
if (mode & RZ_PRINT_DOT) {
rz_strbuf_appendf(outbuf, "%s.%s", fmtname, enumvalue);
} else if (MUSTSEEJSON) {
rz_strbuf_appendf(outbuf, "%" PFMT64d ",\"label\":\"%s\",\"enum\":\"%s\"}",
addr, enumvalue, fmtname);
} else if (MUSTSEE) {
rz_strbuf_appendf(outbuf, "%s (enum %s) = 0x%" PFMT64x " ; %s\n",
fieldname, fmtname, addr, enumvalue);
} else if (MUSTSEESTRUCT) {
rz_strbuf_appendf(outbuf, "%s", enumvalue);
}
} else {
if (MUSTSEEJSON) {
rz_strbuf_appendf(outbuf, "%" PFMT64d ",\"enum\":\"%s\"}", addr, fmtname);
} else if (MUSTSEE) {
rz_strbuf_appendf(outbuf, "%s (enum %s) = 0x%" PFMT64x "\n", //`te %s 0x%x`\n",
fieldname, fmtname, addr); // enumvalue); //fmtname, addr);
}
}
}
static void rz_print_format_register(RzStrBuf *outbuf, const RzPrint *p, int mode,
const char *name, const char *setval) {
if (!p || !p->get_register || !p->reg) {
return;
}
RzRegItem *ri = p->get_register(p->reg, name, RZ_REG_TYPE_ANY);
if (ri) {
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "dr %s=%s\n", name, setval);
} else if (MUSTSEE) {
if (!SEEVALUE) {
rz_strbuf_appendf(outbuf, "%s : 0x%08" PFMT64x "\n", ri->name, p->get_register_value(p->reg, ri));
} else {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x "\n", p->get_register_value(p->reg, ri));
}
} else if (MUSTSEEJSON) {
rz_strbuf_appendf(outbuf, "%" PFMT64d "}", p->get_register_value(p->reg, ri));
}
} else {
rz_strbuf_appendf(outbuf, "Register %s does not exists\n", name);
}
}
static void rz_type_format_num_specifier(RzStrBuf *outbuf, ut64 addr, int bytes, int sign) {
#define EXT(T) (sign ? (signed T)(addr) : (unsigned T)(addr))
const char *fs64 = sign ? "%" PFMT64d : "%" PFMT64u;
const char *fs = sign ? "%d" : "%u";
if (bytes == 1) {
rz_strbuf_appendf(outbuf, fs, EXT(char));
} else if (bytes == 2) {
rz_strbuf_appendf(outbuf, fs, EXT(short));
} else if (bytes == 4) {
rz_strbuf_appendf(outbuf, fs, EXT(int)); // XXX: int is not necessarily 4 bytes I guess.
} else if (bytes == 8) {
rz_strbuf_appendf(outbuf, fs64, addr);
}
#undef EXT
}
static void rz_type_format_num(RzStrBuf *outbuf, int endian, int mode, const char *setval, ut64 seeki, ut8 *buf, int i, int bytes, int sign, int size) {
ut64 addr = 0LL;
int elem = -1;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
if (bytes == 8) {
updateAddr(buf + i, size - i, endian, NULL, &addr, false);
} else {
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
}
if (MUSTSET) {
rz_strbuf_appendf(outbuf, "wv%d %s @ 0x%08" PFMT64x "\n", bytes, setval, seeki + ((elem >= 0) ? elem * (bytes) : 0));
} else if ((mode & RZ_PRINT_DOT) || MUSTSEESTRUCT) {
rz_type_format_num_specifier(outbuf, addr, bytes, sign);
} else if (MUSTSEE) {
if (!SEEVALUE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " = ", seeki + ((elem >= 0) ? elem * bytes : 0));
}
if (size == -1) {
rz_type_format_num_specifier(outbuf, addr, bytes, sign);
} else {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[ ");
}
while (size--) {
if (bytes == 8) {
updateAddr(buf + i, size - i, endian, NULL, &addr, false);
} else {
updateAddr(buf + i, size - i, endian, &addr, NULL, false);
}
if (elem == -1 || elem == 0) {
rz_type_format_num_specifier(outbuf, addr, bytes, sign);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += bytes;
}
if (!SEEVALUE) {
rz_strbuf_append(outbuf, " ]");
}
}
} else if (MUSTSEEJSON) {
if (size == -1) {
rz_type_format_num_specifier(outbuf, addr, bytes, sign);
} else {
rz_strbuf_append(outbuf, "[ ");
while (size--) {
if (bytes == 8) {
updateAddr(buf + i, size, endian, NULL, &addr, false);
} else {
updateAddr(buf + i, size, endian, &addr, NULL, false);
}
if (elem == -1 || elem == 0) {
rz_type_format_num_specifier(outbuf, addr, bytes, sign);
if (elem == 0) {
elem = -2;
}
}
if (size != 0 && elem == -1) {
rz_strbuf_append(outbuf, ", ");
}
if (elem > -1) {
elem--;
}
i += bytes;
}
rz_strbuf_append(outbuf, " ]");
}
rz_strbuf_append(outbuf, "}");
}
}
// XXX: this is somewhat incomplete. must be updated to handle all format chars
RZ_API int rz_type_format_struct_size(const RzTypeDB *typedb, const char *f, int mode, int n) {
char *end, *args, *fmt;
int size = 0, tabsize = 0, i, idx = 0, biggest = 0, fmt_len = 0, times = 1;
bool tabsize_set = false;
if (!f) {
return -1;
}
if (n >= 5) { // This is the nesting level, is this not a bit arbitrary?!
return 0;
}
const char *fmt2 = rz_type_db_format_get(typedb, f);
if (!fmt2) {
fmt2 = f;
}
char *o = strdup(fmt2);
if (!o) {
return -1;
}
end = strchr(o, ' ');
fmt = o;
if (!end && !(end = strchr(o, '\0'))) {
free(o);
return -1;
}
if (*end) {
*end = 0;
args = strdup(end + 1);
} else {
args = strdup("");
}
if (fmt[0] == '{') {
char *end = strchr(fmt + 1, '}');
if (!end) {
RZ_LOG_ERROR("No end curly bracket.\n");
free(o);
free(args);
return -1;
}
*end = '\0';
times = rz_num_math(NULL, fmt + 1);
fmt = end + 1;
}
if (fmt[0] == '0') {
mode |= RZ_PRINT_UNIONMODE;
fmt++;
} else {
mode &= ~RZ_PRINT_UNIONMODE;
}
int words = rz_str_word_set0_stack(args);
fmt_len = strlen(fmt);
for (i = 0; i < fmt_len; i++) {
if (fmt[i] == '[') {
char *end = strchr(fmt + i, ']');
if (!end) {
RZ_LOG_ERROR("No end bracket.\n");
continue;
}
*end = '\0';
tabsize_set = true;
tabsize = rz_num_math(NULL, fmt + i + 1);
*end = ']';
while (fmt[i++] != ']') {
;
}
} else {
tabsize = 1;
}
switch (fmt[i]) {
case '.':
idx--;
// fallthrough
case 'c':
case 'b':
case 'X':
size += tabsize * 1;
break;
case 'w':
size += tabsize * 2;
break;
case ':':
idx--;
// fallthrough
case 'd':
case 'o':
case 'i':
case 'x':
case 'f':
case 's':
case 't':
size += tabsize * 4;
break;
case 'S':
case 'q':
case 'F':
size += tabsize * 8;
break;
case 'Q': // uint128
size += tabsize * 16;
break;
case 'z':
case 'Z':
size += tabsize;
break;
case '*':
size += tabsize * (typedb->target->bits / 8);
i++;
idx--; // no need to go ahead for args
break;
case 'B':
case 'E':
if (tabsize_set) {
if (tabsize < 1 || tabsize > 8) {
RZ_LOG_ERROR("Unknown enum format size: %d\n", tabsize);
break;
}
size += tabsize;
} else {
size += 4; // Assuming by default enum as int
}
break;
case '?': {
const char *wordAtIndex = NULL;
const char *format = NULL;
char *endname = NULL, *structname = NULL;
char tmp = 0;
if (words < idx) {
RZ_LOG_ERROR("Index out of bounds\n");
} else {
wordAtIndex = rz_str_word_get0(args, idx);
}
if (!wordAtIndex) {
break;
}
structname = strdup(wordAtIndex);
if (*structname == '(') {
endname = (char *)rz_str_rchr(structname, NULL, ')');
} else {
free(structname);
break;
}
if (endname) {
*endname = '\0';
}
format = strchr(structname, ' ');
if (format) {
tmp = *format;
while (tmp == ' ') {
format++;
tmp = *format;
}
} else {
format = rz_type_db_format_get(typedb, structname + 1);
if (format && !strncmp(format, f, strlen(format) - 1)) { // Avoid recursion here
free(o);
free(structname);
return -1;
}
if (!format) { // Fetch format from types db
format = rz_type_format(typedb, structname + 1);
}
}
if (!format) {
RZ_LOG_ERROR("Cannot find format for struct `%s'\n", structname + 1);
free(structname);
free(o);
return 0;
}
int newsize = rz_type_format_struct_size(typedb, format, mode, n + 1);
if (newsize < 1) {
RZ_LOG_ERROR("Cannot find size for `%s'\n", format);
free(structname);
free(o);
return 0;
}
if (format) {
size += tabsize * newsize;
}
free(structname);
} break;
case '{':
while (fmt[i] != '}') {
if (!fmt[i]) {
free(o);
free(args);
return -1;
}
i++;
}
i++;
idx--;
break;
case '}':
free(o);
free(args);
return -1;
case '+':
case 'e':
idx--;
break;
case 'p':
if (fmt[i + 1] == '2') {
size += tabsize * 2;
} else if (fmt[i + 1] == '4') {
size += tabsize * 4;
} else if (fmt[i + 1] == '8') {
size += tabsize * 8;
} else {
size += tabsize * (typedb->target->bits / 8);
break;
}
i++;
break;
case 'r':
break;
case 'n':
case 'N':
if (fmt[i + 1] == '1') {
size += tabsize * 1;
} else if (fmt[i + 1] == '2') {
size += tabsize * 2;
} else if (fmt[i + 1] == '4') {
size += tabsize * 4;
} else if (fmt[i + 1] == '8') {
size += tabsize * 8;
} else {
RZ_LOG_ERROR("Invalid '%c' format in (%s)\n", fmt[i + 1], fmt);
free(o);
free(args);
return -2;
}
i++;
break;
case 'u':
case 'D':
case 'T':
// TODO complete this.
default:
// idx--; //Does this makes sense?
break;
}
idx++;
if (mode & RZ_PRINT_UNIONMODE) {
if (size > biggest) {
biggest = size;
}
size = 0;
}
}
size *= times;
free(o);
free(args);
return (mode & RZ_PRINT_UNIONMODE) ? biggest : size;
}
static int rz_type_format_data_internal(const RzTypeDB *typedb, RzPrint *p, RzStrBuf *outbuf, ut64 seek, const ut8 *b, const int len,
const char *formatname, int mode, const char *setval, char *ofield);
static int rz_type_format_struct(const RzTypeDB *typedb, RzPrint *p, RzStrBuf *outbuf, ut64 seek, const ut8 *b, int len, const char *name,
int slide, int mode, const char *setval, char *field, int anon) {
char *fmt;
int ret = 0;
char namefmt[128];
slide++;
if ((slide % STRUCTPTR) > NESTDEPTH || (slide % STRUCTFLAG) / STRUCTPTR > NESTDEPTH) {
eprintf("Too much nested struct, recursion too deep...\n");
return 0;
}
if (anon) {
fmt = strdup(name);
} else {
const char *dbfmt = rz_type_db_format_get(typedb, name);
if (!dbfmt) { // Fetch struct info from types DB
fmt = rz_type_format(typedb, name);
} else {
fmt = strdup(dbfmt);
}
}
if (RZ_STR_ISEMPTY(fmt)) {
eprintf("Undefined struct '%s'.\n", name);
goto beach;
}
if (MUSTSEE && !SEEVALUE) {
snprintf(namefmt, sizeof(namefmt), "%%%ds", 10 + 6 * slide % STRUCTPTR);
if (fmt[0] == '0') {
rz_strbuf_appendf(outbuf, namefmt, "union");
} else {
rz_strbuf_appendf(outbuf, namefmt, "struct");
}
rz_strbuf_appendf(outbuf, "<%s>\n", name);
}
rz_type_format_data_internal(typedb, p, outbuf, seek, b, len, fmt, mode, setval, field);
ret = rz_type_format_struct_size(typedb, fmt, mode, 0);
beach:
free(fmt);
return ret;
}
static char *get_args_offset(const char *arg) {
char *args = strchr(arg, ' ');
char *sq_bracket = strchr(arg, '[');
int max = 30;
if (args && sq_bracket) {
char *csq_bracket = strchr(arg, ']');
while (args && csq_bracket && csq_bracket > args && max--) {
args = strchr(csq_bracket, ' ');
}
}
return args;
}
static char *get_format_type(const char fmt, const char arg) {
char *type = NULL;
switch (fmt) {
case 'b':
case 'C':
type = strdup("uint8_t");
break;
case 'c':
type = strdup("int8_t");
break;
case 'd':
case 'i':
case 'o':
case 'x':
type = strdup("int32_t");
break;
case 'E':
type = strdup("enum");
break;
case 'f':
type = strdup("float");
break;
case 'F':
type = strdup("double");
break;
case 'q':
type = strdup("uint64_t");
break;
case 'u':
type = strdup("uleb128_t");
break;
case 'Q':
type = strdup("uint128_t");
break;
case 'w':
type = strdup("uint16_t");
break;
case 'X':
type = strdup("uint8_t[]");
break;
case 'D':
case 's':
case 'S':
case 't':
case 'z':
case 'Z':
type = strdup("char*");
break;
case 'n':
case 'N':
switch (arg) {
case '1':
type = strdup(fmt == 'n' ? "int8_t" : "uint8_t");
break;
case '2':
type = strdup(fmt == 'n' ? "int16_t" : "uint16_t");
break;
case '4':
type = strdup(fmt == 'n' ? "int32_t" : "uint32_t");
break;
case '8':
type = strdup(fmt == 'n' ? "int64_t" : "uint64_t");
break;
}
break;
}
return type;
}
#define MINUSONE ((void *)(size_t)-1)
#define ISSTRUCT (tmp == '?' || (tmp == '*' && *(arg + 1) == '?'))
RZ_API const char *rz_type_db_format_get(const RzTypeDB *typedb, const char *name) {
rz_return_val_if_fail(typedb && name, NULL);
bool found = false;
const char *result = ht_pp_find(typedb->formats, name, &found);
if (!found || !result) {
// eprintf("Cannot find format \"%s\"\n", name);
return NULL;
}
return result;
}
RZ_API void rz_type_db_format_set(RzTypeDB *typedb, const char *name, const char *fmt) {
rz_return_if_fail(typedb && name && fmt);
// TODO: We should check if the file format is valid (e.g. syntax) before storing it
ht_pp_insert(typedb->formats, name, strdup(fmt));
}
static bool format_collect_cb(void *user, const void *k, const void *v) {
rz_return_val_if_fail(user && k && v, false);
RzList *l = user;
RzTypeFormat *fmt = RZ_NEW0(RzTypeFormat);
fmt->name = (const char *)k;
fmt->body = (const char *)v;
rz_list_append(l, fmt);
return true;
}
RZ_API RZ_OWN RzList /**/ *rz_type_db_format_all(RzTypeDB *typedb) {
rz_return_val_if_fail(typedb, NULL);
RzList *formats = rz_list_new();
ht_pp_foreach(typedb->formats, format_collect_cb, formats);
return formats;
}
RZ_API void rz_type_db_format_delete(RzTypeDB *typedb, const char *name) {
rz_return_if_fail(typedb && name);
ht_pp_delete(typedb->formats, name);
}
static int rz_type_format_data_internal(const RzTypeDB *typedb, RzPrint *p, RzStrBuf *outbuf, ut64 seek, const ut8 *b, const int len,
const char *formatname, int mode, const char *setval, char *ofield) {
int nargs, i, invalid, nexti, idx, times, otimes, endian, isptr = 0;
const int old_bits = typedb->target->bits;
char *args = NULL, *bracket, tmp, last = 0;
ut64 addr = 0, addr64 = 0, seeki = 0;
static int slide = 0, oldslide = 0, ident = 4;
char namefmt[32], *field = NULL;
const char *arg = NULL;
const char *fmt = NULL;
const char *argend;
int viewflags = 0;
char *oarg = NULL;
char *internal_format = NULL;
/* Load format from name into fmt */
if (!formatname) {
return 0;
}
fmt = rz_type_db_format_get(typedb, formatname);
if (!fmt) {
fmt = formatname;
}
internal_format = strdup(fmt);
fmt = internal_format;
while (*fmt && IS_WHITECHAR(*fmt)) {
fmt++;
}
argend = fmt + strlen(fmt);
arg = fmt;
nexti = nargs = i = 0;
if (len < 1) {
free(internal_format);
return 0;
}
// len+2 to save space for the null termination in wide strings
ut8 *buf = calloc(1, len + 2);
if (!buf) {
free(internal_format);
return 0;
}
memcpy(buf, b, len);
endian = typedb->target->big_endian;
if (ofield && ofield != MINUSONE) {
field = strdup(ofield);
}
/* get times */
otimes = times = atoi(arg);
if (times > 0) {
while (IS_DIGIT(*arg)) {
arg++;
}
}
bracket = strchr(arg, '{');
if (bracket) {
char *end = strchr(arg, '}');
if (!end) {
eprintf("No end bracket. Try pf {ecx}b @ esi\n");
goto beach;
}
*end = '\0';
times = rz_num_math(NULL, bracket + 1);
arg = end + 1;
}
if (*arg == '\0') {
goto beach;
}
/* get args */
args = get_args_offset(arg);
if (args) {
int maxl = 0;
argend = args;
tmp = *args;
while (tmp == ' ') {
args++;
tmp = *args;
}
args = strdup(args);
nargs = rz_str_word_set0_stack(args);
if (nargs == 0) {
RZ_FREE(args);
}
for (i = 0; i < nargs; i++) {
const char *tmp = rz_str_word_get0(args, i);
const char *nm = rz_str_rchr(tmp, NULL, ')');
int len = strlen(nm ? nm + 1 : tmp);
if (len > maxl) {
maxl = len;
}
}
const char *ends = " "; // XXX trailing space warning
snprintf(namefmt, sizeof(namefmt), "%%%ds :%s",
((maxl + 1) * (1 + slide)) % STRUCTPTR, ends);
}
#define ISPOINTED ((slide % STRUCTFLAG) / STRUCTPTR <= (oldslide % STRUCTFLAG) / STRUCTPTR)
#define ISNESTED ((slide % STRUCTPTR) <= (oldslide % STRUCTPTR))
if (mode == RZ_PRINT_JSON && slide == 0) {
rz_strbuf_append(outbuf, "[");
}
if (mode == RZ_PRINT_STRUCT) {
if (formatname && *formatname) {
if (strchr(formatname, ' ')) {
rz_strbuf_append(outbuf, "struct {\n");
} else {
rz_strbuf_appendf(outbuf, "struct %s {\n", formatname);
}
} else {
rz_strbuf_append(outbuf, "struct {\n");
}
}
if (mode && arg[0] == '0') {
mode |= RZ_PRINT_UNIONMODE;
arg++;
} else {
mode &= ~RZ_PRINT_UNIONMODE;
}
if (mode & RZ_PRINT_DOT) {
char *fmtname;
if (formatname && *formatname) {
if (strchr(formatname, ' ')) {
fmtname = rz_str_newf("0x%" PFMT64x, seek);
} else {
fmtname = strdup(formatname);
}
} else {
fmtname = rz_str_newf("0x%" PFMT64x, seek);
}
rz_strbuf_append(outbuf, "digraph g { graph [ rank=same; rankdir=LR; ];\n");
rz_strbuf_appendf(outbuf, "root [ rank=1; shape=record\nlabel=\"%s", fmtname);
}
/* go format */
i = 0;
if (!times) {
otimes = times = 1;
}
for (; times; times--) { // repeat N times
const char *orig = arg;
int first = 1;
if (otimes > 1) {
if (mode & RZ_PRINT_JSON) {
if (otimes > times) {
rz_strbuf_append(outbuf, ",");
}
rz_strbuf_appendf(outbuf, "[{\"index\":%d,\"offset\":%" PFMT64d "},", otimes - times, seek + i);
} else if (mode) {
rz_strbuf_appendf(outbuf, "0x%08" PFMT64x " [%d] {\n", seek + i, otimes - times);
}
}
arg = orig;
for (idx = 0; i < len && arg < argend && *arg; arg++) {
int size = 0, elem = 0; /* size of the array, element of the array */
char *fieldname = NULL, *fmtname = NULL;
if (mode & RZ_PRINT_UNIONMODE) {
i = 0;
}
seeki = seek + i;
addr = 0LL;
invalid = 0;
typedb->target->bits = old_bits;
if (arg[0] == '[') {
char *end = strchr(arg, ']');
if (!end) {
eprintf("No end bracket.\n");
goto beach;
}
*end = '\0';
size = rz_get_size(typedb->num, buf, endian, arg + 1);
arg = end + 1;
*end = ']';
} else {
size = -1;
}
int fs = rz_type_format_struct_size(typedb, arg, 0, idx);
if (fs == -2) {
i = -1;
goto beach;
}
if (fs < 1) {
fs = 4;
}
if (i + fs - 1 < len) { // should be +7 to avoid oobread on 'q'
// Max byte number where updateAddr will look into
if (len - i < 7) {
updateAddr(buf + i, THRESHOLD - (len - i), endian, &addr, &addr64, false);
} else {
updateAddr(buf + i, len - i, endian, &addr, &addr64, false);
}
if (typedb->target->bits == 64) {
addr = addr64;
}
} else {
// eprintf ("Format strings is too big for this buffer\n");
goto beach;
}
tmp = *arg;
if (mode && !args) {
mode |= RZ_PRINT_ISFIELD;
}
if (!(mode & RZ_PRINT_QUIET)) {
if (mode & RZ_PRINT_MUSTSEE && otimes > 1) {
rz_strbuf_append(outbuf, " ");
}
}
if (idx < nargs && tmp != 'e' && isptr == 0) {
char *dot = NULL, *bracket = NULL;
if (field) {
dot = strchr(field, '.');
}
if (dot) {
*dot = '\0';
}
free(oarg);
oarg = fieldname = strdup(rz_str_word_get0(args, idx));
if (ISSTRUCT || tmp == 'E' || tmp == 'B' || tmp == 'r') {
if (*fieldname == '(') {
fmtname = fieldname + 1;
fieldname = (char *)rz_str_rchr(fieldname, NULL, ')');
if (fieldname) {
*fieldname++ = '\0';
} else {
eprintf("Missing closing parenthesis in format ')'\n");
goto beach;
}
} else {
eprintf("Missing name (%s)\n", fieldname);
goto beach;
}
}
if (mode && (!args || (!field && ofield != MINUSONE) || (field && !strncmp(field, fieldname, strchr(field, '[') ? strchr(field, '[') - field : strlen(field) + 1)))) {
mode |= RZ_PRINT_ISFIELD;
} else {
mode &= ~RZ_PRINT_ISFIELD;
}
/* There we handle specific element in array */
if (field && (bracket = strchr(field, '[')) && mode & RZ_PRINT_ISFIELD) {
char *end = strchr(field, ']');
if (!end) {
eprintf("Missing closing bracket\n");
goto beach;
}
*end = '\0';
elem = rz_num_math(NULL, bracket + 1) + 1; // +1 to handle 0 index easily
for (; bracket < end; bracket++) {
*bracket = '\0';
}
size += elem * ARRAYINDEX_COEF;
} else {
elem = -1;
}
if (tmp != '.' && tmp != ':') {
idx++;
if (MUSTSEE && !SEEVALUE) {
if (!ISQUIET) {
rz_strbuf_appendf(outbuf, namefmt, fieldname);
}
}
}
}
feed_me_again:
switch (isptr) {
case PTRSEEK: {
nexti = i + (typedb->target->bits / 8);
i = 0;
if (tmp == '?') {
seeki = addr;
}
memset(buf, '\0', len);
if (MUSTSEE && !ISQUIET) {
rz_strbuf_appendf(outbuf, "(*0x%" PFMT64x ")", addr);
}
isptr = (addr) ? PTRBACK : NULLPTR;
typedb->iob.read_at(typedb->iob.io, (ut64)addr, buf, len - 4);
if (((i + 3) < len) || ((i + 7) < len)) {
// XXX this breaks pf *D
if (tmp != 'D') {
updateAddr(buf + i, len - i, endian, &addr, &addr64, false);
}
} else {
eprintf("(cannot read at 0x%08" PFMT64x ", block: %s, blocksize: 0x%x)\n",
addr, b, len);
rz_strbuf_append(outbuf, "\n");
goto beach;
}
} break;
case PTRBACK:
// restore state after pointer seek
i = nexti;
memcpy(buf, b, len);
isptr = NOPTR;
arg--;
continue;
}
if (tmp == 0 && last != '*') {
break;
}
/* skip chars */
switch (tmp) {
case '*': // next char is a pointer
isptr = PTRSEEK;
arg++;
tmp = *arg; // last;
goto feed_me_again;
case '+': // toggle view flags
viewflags = !viewflags;
continue;
case 'e': // tmp swap endian
endian ^= 1;
continue;
case ':': // skip 4 bytes
if (size == -1) {
i += 4;
} else {
while (size--) {
i += 4;
}
}
continue;
case '.': // skip 1 byte
i += (size == -1) ? 1 : size;
continue;
case 'p': // pointer reference
if (*(arg + 1) == '2') {
tmp = 'w';
arg++;
} else if (*(arg + 1) == '4') {
tmp = 'x';
arg++;
} else if (*(arg + 1) == '8') {
tmp = 'q';
arg++;
} else { // If pointer reference is not mentioned explicitly
switch (typedb->target->bits) {
case 16: tmp = 'w'; break;
case 32: tmp = 'x'; break;
default: tmp = 'q'; break;
}
}
break;
}
/* flags */
if (mode & RZ_PRINT_SEEFLAGS && isptr != NULLPTR) {
char *newname = NULL;
if (!fieldname) {
newname = fieldname = rz_str_newf("pf.%" PFMT64u, seeki);
}
if (mode & RZ_PRINT_UNIONMODE) {
rz_strbuf_appendf(outbuf, "f %s @ 0x%08" PFMT64x "\n", formatname, seeki);
free(newname);
goto beach;
} else if (tmp == '?') {
rz_strbuf_appendf(outbuf, "f %s.%s_", fmtname, fieldname);
} else if (tmp == 'E') {
rz_strbuf_appendf(outbuf, "f %s @ 0x%08" PFMT64x "\n", fieldname, seeki);
} else if (slide / STRUCTFLAG > 0 && idx == 1) {
rz_strbuf_appendf(outbuf, "%s @ 0x%08" PFMT64x "\n", fieldname, seeki);
} else {
rz_strbuf_appendf(outbuf, "f %s @ 0x%08" PFMT64x "\n", fieldname, seeki);
}
if (newname) {
RZ_FREE(newname);
fieldname = NULL;
}
}
/* dot */
if (mode & RZ_PRINT_DOT) {
if (fieldname) {
rz_strbuf_appendf(outbuf, "|{0x%" PFMT64x "|%c|%s|<%s>",
seeki, tmp, fieldname, fieldname);
} else {
rz_strbuf_appendf(outbuf, "|{0x%" PFMT64x "|%c|",
seeki, tmp);
}
}
/* json */
if (MUSTSEEJSON && mode & RZ_PRINT_JSON) {
if (oldslide <= slide) {
if (first) {
first = 0;
} else {
rz_strbuf_append(outbuf, ",");
}
} else if (oldslide) {
rz_strbuf_append(outbuf, "]},");
oldslide -= NESTEDSTRUCT;
}
if (fieldname) {
rz_strbuf_appendf(outbuf, "{\"name\":\"%s\",\"type\":\"", fieldname);
} else {
rz_strbuf_append(outbuf, "{\"type\":\"");
}
if (ISSTRUCT) {
rz_strbuf_appendf(outbuf, "%s", fmtname);
} else {
if (tmp == 'n' || tmp == 'N') {
rz_strbuf_appendf(outbuf, "%c%c", tmp, *(arg + 1));
} else {
rz_strbuf_appendf(outbuf, "%c", tmp);
}
}
if (isptr) {
rz_strbuf_append(outbuf, "*");
}
rz_strbuf_appendf(outbuf, "\",\"offset\":%" PFMT64d ",\"value\":",
isptr ? (seek + nexti - (typedb->target->bits / 8)) : seek + i);
}
/* c struct */
if (MUSTSEESTRUCT) {
char *type = get_format_type(tmp, (tmp == 'n' || tmp == 'N') ? arg[1] : 0);
if (type) {
rz_strbuf_appendf(outbuf, "%*c%s %s; // ", ident, ' ', type, fieldname);
} else {
rz_strbuf_appendf(outbuf, "%*cstruct %s {", ident, ' ', fieldname);
}
free(type);
}
bool noline = false;
int oi = i;
if (isptr == NULLPTR) {
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "\"NULL\"}");
} else if (MUSTSEE) {
rz_strbuf_append(outbuf, " NULL\n");
}
isptr = PTRBACK;
} else {
/* format chars */
// before to enter in the switch statement check buf boundaries due to updateAddr
// might go beyond its len and it's usually called in each of the following functions
switch (tmp) {
case 'u':
i += rz_type_format_uleb(outbuf, endian, mode, setval, seeki, buf, i, size);
break;
case 't':
rz_type_format_time(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 4 : 4 * size;
break;
case 'q':
rz_type_format_quadword(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 8 : 8 * size;
break;
case 'Q':
rz_type_format_u128(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 16 : 16 * size;
break;
case 'b':
rz_type_format_byte(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 1 : size;
break;
case 'C':
rz_type_format_decchar(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 1 : size;
break;
case 'c':
rz_type_format_char(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 1 : size;
break;
case 'X':
size = rz_type_format_hexpairs(outbuf, endian, mode, setval, seeki, buf, i, size);
i += size;
break;
case 'T':
if (rz_type_format_10bytes(typedb, outbuf, mode,
setval, seeki, addr, buf) == 0) {
i += (size == -1) ? 4 : 4 * size;
}
break;
case 'f':
rz_type_format_float(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 4 : 4 * size;
break;
case 'F':
rz_type_format_double(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 8 : 8 * size;
break;
case 'i':
rz_type_format_int(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 4 : 4 * size;
break;
case 'd': // WHY?? help says: 0x%%08x hexadecimal value (4 bytes)
rz_type_format_hex(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 4 : 4 * size;
break;
/*
case 'D':
if (isptr) {
if (typedb->target->bits == 64) {
i += rz_print_format_disasm(p, addr64, size);
} else {
i += rz_print_format_disasm(p, addr, size);
}
} else {
i += rz_print_format_disasm(p, seeki, size);
}
break;
*/
case 'o':
rz_type_format_octal(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 4 : 4 * size;
break;
case ';':
noline = true;
i -= (size == -1) ? 4 : 4 * size;
if (i < 0) {
i = 0;
}
break;
case ',':
noline = true;
i -= (size == -1) ? 1 : size;
if (i < 0) {
i = 0;
}
break;
case 'x':
rz_type_format_hexflag(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 4 : 4 * size;
break;
case 'w':
rz_type_format_word(outbuf, endian, mode, setval, seeki, buf, i, size);
i += (size == -1) ? 2 : 2 * size;
break;
case 'z': // zero terminated string
rz_type_format_nulltermstring(typedb, p, outbuf, len, endian, mode, setval, seeki, buf, i, size);
if (size == -1) {
i += strlen((char *)buf + i) + 1;
} else {
while (size--) {
i++;
}
}
break;
case 'Z': // zero terminated wide string
rz_type_format_nulltermwidestring(p, outbuf, len, endian, mode, setval, seeki, buf, i, size);
if (size == -1) {
i += rz_wstr_clen((char *)(buf + i)) * 2 + 2;
} else {
while (size--) {
i += 2;
}
}
break;
case 's':
if (rz_type_format_string(typedb, outbuf, seeki, addr64, addr, 0, mode) == 0) {
i += (size == -1) ? 4 : 4 * size;
}
break;
case 'S':
if (rz_type_format_string(typedb, outbuf, seeki, addr64, addr, 1, mode) == 0) {
i += (size == -1) ? 8 : 8 * size;
}
break;
case 'B': // resolve bitfield
if (size >= ARRAYINDEX_COEF) {
size %= ARRAYINDEX_COEF;
}
rz_type_format_bitfield(typedb, outbuf, seeki, fmtname, fieldname, addr, mode, size);
i += (size == -1) ? 1 : size;
break;
case 'E': // resolve enum
if (size >= ARRAYINDEX_COEF) {
size %= ARRAYINDEX_COEF;
}
rz_type_format_enum(typedb, outbuf, seeki, fmtname, fieldname, addr, mode, size);
i += (size == -1) ? 1 : size;
break;
case 'r':
if (fmtname) {
rz_print_format_register(outbuf, p, mode, fmtname, setval);
} else {
eprintf("Unknown register\n");
}
break;
case '?': {
int s = 0;
char *nxtfield = NULL;
char *format = NULL;
int anon = 0;
if (size >= ARRAYINDEX_COEF) {
elem = size / ARRAYINDEX_COEF - 1;
size %= ARRAYINDEX_COEF;
}
if (!(mode & RZ_PRINT_ISFIELD)) {
nxtfield = MINUSONE;
} else if (field) {
nxtfield = strchr(ofield, '.');
}
if (nxtfield != MINUSONE && nxtfield) {
nxtfield++;
}
if (MUSTSEE) {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "\n");
}
}
if (MUSTSEEJSON) {
if (isptr) {
rz_strbuf_appendf(outbuf, "%" PFMT64d "},", seeki);
} else {
rz_strbuf_append(outbuf, "[");
}
}
if (MUSTSEESTRUCT) {
if (isptr) {
rz_strbuf_appendf(outbuf, "%" PFMT64d, seeki);
} else {
ident += 4;
rz_strbuf_append(outbuf, "\n");
}
}
if (mode & RZ_PRINT_SEEFLAGS) {
slide += STRUCTFLAG;
}
if (!fmtname) {
break;
}
format = strchr(fmtname, ' ');
if (format) {
anon = 1;
fmtname = format;
while (*fmtname == ' ') {
fmtname++;
}
}
oldslide = slide;
// slide += (isptr) ? STRUCTPTR : NESTEDSTRUCT;
slide += NESTEDSTRUCT;
if (size == -1) {
s = rz_type_format_struct(typedb, p, outbuf, seeki,
buf + i, len - i, fmtname, slide,
mode, setval, nxtfield, anon);
i += (isptr) ? (typedb->target->bits / 8) : s;
if (MUSTSEEJSON) {
if (!isptr && (!arg[1] || arg[1] == ' ')) {
rz_strbuf_append(outbuf, "]}");
}
}
} else {
if (mode & RZ_PRINT_ISFIELD) {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "[\n");
}
}
while (size--) {
if (mode && (elem == -1 || elem == 0)) {
mode |= RZ_PRINT_MUSTSEE;
if (elem == 0) {
elem = -2;
}
} else {
mode &= ~RZ_PRINT_MUSTSEE;
}
s = rz_type_format_struct(typedb, p, outbuf, seek + i,
buf + i, len - i, fmtname, slide, mode, setval, nxtfield, anon);
if ((MUSTSEE || MUSTSEEJSON || MUSTSEESTRUCT) && size != 0 && elem == -1) {
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, ",");
} else if (MUSTSEE || MUSTSEESTRUCT) {
rz_strbuf_append(outbuf, "\n");
}
}
if (elem > -1) {
elem--;
}
i += (isptr) ? (typedb->target->bits / 8) : s;
}
if (mode & RZ_PRINT_ISFIELD) {
if (!SEEVALUE) {
rz_strbuf_append(outbuf, "]\n");
}
}
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "]}");
}
}
oldslide = slide;
// slide -= (isptr) ? STRUCTPTR : NESTEDSTRUCT;
slide -= NESTEDSTRUCT;
if (mode & RZ_PRINT_SEEFLAGS) {
oldslide = slide;
slide -= STRUCTFLAG;
}
break;
}
case 'n':
case 'N': {
int bytes = 0;
int sign = (tmp == 'n') ? 1 : 0;
if (arg[1] == '1') {
bytes = 1;
} else if (arg[1] == '2') {
bytes = 2;
} else if (arg[1] == '4') {
bytes = 4;
} else if (arg[1] == '8') {
bytes = 8;
} else {
invalid = 1;
break;
// or goto beach;???
}
rz_type_format_num(outbuf, endian, mode, setval, seeki, buf, i, bytes, sign, size);
i += (size == -1) ? bytes : size * bytes;
arg++;
break;
}
default:
/* ignore unknown chars */
invalid = 1;
break;
} // switch
}
if (MUSTSEESTRUCT) {
if (oldslide) {
ident -= 4;
rz_strbuf_appendf(outbuf, "%*c}", ident, ' ');
oldslide -= NESTEDSTRUCT;
}
rz_strbuf_append(outbuf, "\n");
}
if (mode & RZ_PRINT_DOT) {
rz_strbuf_append(outbuf, "}");
}
if (mode & RZ_PRINT_SEEFLAGS && isptr != NULLPTR) {
int sz = i - oi;
if (sz > 1) {
rz_strbuf_appendf(outbuf, "fL %d @ 0x%08" PFMT64x "\n", sz, seeki);
rz_strbuf_appendf(outbuf, "Cd %d @ 0x%08" PFMT64x "\n", sz, seeki);
}
}
if (viewflags && p->offname) {
const char *s = p->offname(p->user, seeki);
if (s) {
rz_strbuf_appendf(outbuf, "@(%s)", s);
}
s = p->offname(p->user, addr);
if (s) {
rz_strbuf_appendf(outbuf, "*(%s)", s);
}
}
if (!noline && tmp != 'D' && !invalid && !fmtname && MUSTSEE) {
rz_strbuf_append(outbuf, "\n");
}
last = tmp;
// XXX: Due to the already noted issues with the above, we need to strip
// args from fmt:args the same way we strip fmt BUT only for enums as
// nested structs seem to be handled correctly above!
if (arg[0] == 'E') {
char *end_fmt = strchr(arg, ' ');
if (!end_fmt) {
goto beach;
}
char *next_args = strchr(end_fmt + 1, ' ');
if (next_args) {
while (*next_args != '\0') {
*end_fmt++ = *next_args++;
}
}
*end_fmt = '\0';
}
}
if (otimes > 1) {
if (MUSTSEEJSON) {
rz_strbuf_append(outbuf, "]");
} else if (mode) {
rz_strbuf_append(outbuf, "}\n");
}
}
arg = orig;
oldslide = 0;
}
if (mode & RZ_PRINT_JSON && slide == 0) {
rz_strbuf_append(outbuf, "]");
}
if (MUSTSEESTRUCT && slide == 0) {
rz_strbuf_append(outbuf, "}\n");
}
if (mode & RZ_PRINT_DOT) {
rz_strbuf_append(outbuf, "\"];\n}\n");
// TODO: show nested structs and field reference lines
}
beach:
if (slide == 0) {
oldslide = 0;
}
free(internal_format);
free(oarg);
free(buf);
free(field);
free(args);
return i;
}
/**
* \brief Applies `pf` format string to a data
*
* \param typedb Types Database instance
* \param p RzPrint instance
* \param seek An offset in the binary to which apply the format
* \param b A buffer from which take the data
* \param len Length of the data
* \param formatname Format name
* \param mode RzPrint mode
* \param setval Format field value in the writing mode
* \param ofield Format field
*/
RZ_API RZ_OWN char *rz_type_format_data(const RzTypeDB *typedb, RzPrint *p, ut64 seek, const ut8 *b, const int len,
const char *formatname, int mode, const char *setval, char *ofield) {
RzStrBuf *outbuf = rz_strbuf_new("");
rz_type_format_data_internal(typedb, p, outbuf, seek, b, len, formatname, mode, setval, ofield);
char *outstr = rz_strbuf_drain(outbuf);
return outstr;
}
/* Every format string essentially contains two parts:
* 1. The format (`pf` string) itself
* 2. The field name and types, "(field_type)field_name"
* Both parts are separated from each other by space
*
* Example:
* "[2]Ewtxxw[2]B (pe_machine)machine NumberOfSections TimeDateStamp PointerToSymbolTable NumberOfSymbols SizeOfOptionalHeader (pe_characteristics)Characteristics"
* Here "[2]Ewtxxw[2]B" is the `pf` string while the rest are field names and types.
* E.g. "(pe_machine)" is the field type, previously defined enum called "pe_machine"
* "machine" here is the field name. The corresponding construction in C is:
* struct {
* pe_machine machine;
* uint16_t NumberOfSections;
* datetime_t TimeDateStamp;
* uint32_t PointerToSymbolTable;
* uint32_t NumberOfSymbols;
* uint16_t SizeOfOptionalHeader;
* pe_characteristics characteristics; // (bitfield enum)
* };
*/
static const char *type_to_identifier(const RzTypeDB *typedb, RzType *type) {
if (type->kind == RZ_TYPE_KIND_IDENTIFIER) {
return type->identifier.name;
} else if (type->kind == RZ_TYPE_KIND_ARRAY) {
return type_to_identifier(typedb, type->array.type);
} else if (type->kind == RZ_TYPE_KIND_POINTER) {
return type_to_identifier(typedb, type->pointer.type);
} else if (type->kind == RZ_TYPE_KIND_CALLABLE) {
return type->callable->name;
}
rz_warn_if_reached();
return NULL;
}
static bool type_to_format_pair(const RzTypeDB *typedb, RzStrBuf *format, RzStrBuf *fields, RZ_NULLABLE const char *identifier, RZ_NONNULL RzType *type);
// This logic applies only to the structure/union members, not the toplevel types
static void base_type_to_format_no_unfold(const RzTypeDB *typedb, RZ_NONNULL RzBaseType *type, RZ_NONNULL const char *identifier, RzStrBuf *format, RzStrBuf *fields) {
rz_return_if_fail(typedb && type && identifier && format && fields);
switch (type->kind) {
case RZ_BASE_TYPE_KIND_STRUCT: {
rz_strbuf_append(format, "?");
rz_strbuf_appendf(fields, "(%s)%s ", type->name, identifier);
break;
}
case RZ_BASE_TYPE_KIND_UNION: {
// In `pf` unions defined like structs but all have 0 offset,
// which is why it uses `0` character as a marker when being unfolded,
// but when folded, they use the same `?` character as structures.
rz_strbuf_append(format, "?");
rz_strbuf_appendf(fields, "(%s)%s ", type->name, identifier);
break;
}
case RZ_BASE_TYPE_KIND_ENUM: {
// Some enums defined as bitfields in the database, so we search if
// it's stored as the `pf` format in the database
const char *fmt = rz_type_db_format_get(typedb, type->name);
if (fmt) {
rz_strbuf_append(format, "B");
} else {
rz_strbuf_append(format, "E");
}
rz_strbuf_appendf(fields, "(%s)%s ", type->name, identifier);
break;
}
case RZ_BASE_TYPE_KIND_TYPEDEF: {
// It might go recursively to find all types behind the alias
// So we check first it refers to itself
if (rz_type_is_identifier(type->type)) {
const char *tidentifier = rz_type_identifier(type->type);
if (RZ_STR_EQ(tidentifier, type->name)) {
// Show it as a pointer instead
rz_strbuf_append(format, "p");
rz_strbuf_appendf(fields, "%s ", identifier);
break;
}
}
char *fmt = rz_type_as_format(typedb, type->type);
if (fmt) {
rz_strbuf_append(format, fmt);
rz_strbuf_appendf(fields, "%s ", identifier);
} else {
type_to_format_pair(typedb, format, fields, identifier, type->type);
}
free(fmt);
break;
}
case RZ_BASE_TYPE_KIND_ATOMIC: {
// We simply skip fields that don't have a format
const char *fmt = rz_type_db_format_get(typedb, type->name);
if (fmt) {
rz_strbuf_append(format, fmt);
rz_strbuf_appendf(fields, "%s ", identifier);
}
break;
}
default:
rz_warn_if_reached();
break;
}
}
// This logic applies to the toplevel types and unfolds the structure/union types
static void base_type_to_format_unfold(const RzTypeDB *typedb, RZ_NONNULL RzBaseType *type, RzStrBuf *format, RzStrBuf *fields, RZ_NULLABLE const char *identifier) {
rz_return_if_fail(typedb && type && format && fields);
switch (type->kind) {
case RZ_BASE_TYPE_KIND_STRUCT: {
RzTypeStructMember *memb;
rz_vector_foreach(&type->struct_data.members, memb) {
const char *membtype = type_to_identifier(typedb, memb->type);
// Avoid infinite recursion in case of self-referential structures
if (!membtype || !strcmp(membtype, type->name)) {
continue;
}
if (rz_type_is_identifier(memb->type)) {
// Search the base type of the same name and generate the format from it
RzBaseType *btyp = rz_type_get_base_type(typedb, memb->type);
if (btyp) {
base_type_to_format_no_unfold(typedb, btyp, memb->name, format, fields);
}
} else {
char *membfmt = rz_type_as_format(typedb, memb->type);
rz_strbuf_append(format, membfmt);
if (!rz_type_is_atomic(typedb, memb->type)) {
rz_strbuf_appendf(fields, "(%s)%s ", membtype, memb->name);
} else {
rz_strbuf_appendf(fields, "%s ", memb->name);
}
free(membfmt);
}
}
break;
}
case RZ_BASE_TYPE_KIND_UNION: {
// In `pf` unions defined like structs but all have 0 offset,
// which is why it uses `0` character as a marker
rz_strbuf_append(format, "0");
RzTypeUnionMember *memb;
rz_vector_foreach(&type->union_data.members, memb) {
const char *membtype = type_to_identifier(typedb, memb->type);
// Avoid infinite recursion in case of self-referential unions
if (!membtype || !strcmp(membtype, type->name)) {
continue;
}
if (rz_type_is_identifier(memb->type)) {
// Search the base type of the same name and generate the format from it
RzBaseType *btyp = rz_type_get_base_type(typedb, memb->type);
if (btyp) {
base_type_to_format_no_unfold(typedb, btyp, memb->name, format, fields);
}
} else {
char *membfmt = rz_type_as_format(typedb, memb->type);
rz_strbuf_append(format, membfmt);
if (!rz_type_is_atomic(typedb, memb->type)) {
rz_strbuf_appendf(fields, "(%s)%s ", membtype, memb->name);
} else {
rz_strbuf_appendf(fields, "%s ", memb->name);
}
free(membfmt);
}
}
break;
}
case RZ_BASE_TYPE_KIND_ENUM:
case RZ_BASE_TYPE_KIND_ATOMIC: {
base_type_to_format_no_unfold(typedb, type, type->name, format, fields);
break;
}
case RZ_BASE_TYPE_KIND_TYPEDEF: {
RzType *unwrapped = rz_type_db_base_type_unwrap_typedef(typedb, type);
if (!unwrapped) {
break;
}
type_to_format_pair(typedb, format, fields, identifier, unwrapped);
break;
}
default:
rz_warn_if_reached();
break;
}
}
/**
* \brief Represents the RzBaseType as a `pf` format string
*
* Produces the pair of of . If the type
* is atomic it searches if the type database has predefined
* format assigned to it and uses it.
*
* \param typedb Types Database instance
* \param type RzBaseType type
*/
RZ_API RZ_OWN char *rz_base_type_as_format(const RzTypeDB *typedb, RZ_NONNULL RzBaseType *type) {
rz_return_val_if_fail(typedb && type && type->name, NULL);
RzStrBuf *format = rz_strbuf_new("");
RzStrBuf *fields = rz_strbuf_new("");
base_type_to_format_unfold(typedb, type, format, fields, NULL);
char *fieldstr = rz_strbuf_drain(fields);
rz_strbuf_appendf(format, " %s", fieldstr);
free(fieldstr);
char *bufstr = rz_strbuf_drain(format);
rz_str_trim_tail(bufstr);
return bufstr;
}
/**
* \brief Represents the RzBaseType as a `pf` format string
*
* Produces the pair of of . If the type
* is atomic it searches if the type database has predefined
* format assigned to it and uses it.
*
* \param typedb Types Database instance
* \param name RzBaseType type name
*/
RZ_API RZ_OWN char *rz_type_format(RZ_NONNULL const RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, NULL);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return NULL;
}
return rz_base_type_as_format(typedb, btype);
}
static void type_to_format(const RzTypeDB *typedb, RzStrBuf *buf, RzType *type) {
if (type->kind == RZ_TYPE_KIND_IDENTIFIER) {
const char *format = rz_type_db_format_get(typedb, type->identifier.name);
if (format) {
rz_strbuf_append(buf, format);
} else {
if (type->identifier.kind == RZ_TYPE_IDENTIFIER_KIND_STRUCT ||
type->identifier.kind == RZ_TYPE_IDENTIFIER_KIND_UNION) {
rz_strbuf_append(buf, "?");
} else if (type->identifier.kind == RZ_TYPE_IDENTIFIER_KIND_ENUM) {
rz_strbuf_append(buf, "E");
} else {
RzBaseType *btyp = rz_type_get_base_type(typedb, type);
if (btyp) {
RzStrBuf *fields = rz_strbuf_new("");
base_type_to_format_no_unfold(typedb, btyp, type->identifier.name, buf, fields);
rz_strbuf_free(fields);
}
}
}
} else if (type->kind == RZ_TYPE_KIND_ARRAY) {
rz_strbuf_appendf(buf, "[%" PFMT64d "]", type->array.count);
type_to_format(typedb, buf, type->array.type);
} else if (type->kind == RZ_TYPE_KIND_POINTER) {
rz_strbuf_append(buf, "*");
type_to_format(typedb, buf, type->pointer.type);
}
}
/**
* \brief Represents the RzType as a `pf` format string
*
* Different from the similar function for the RzBaseType,
* since the latter shows the pair of ,
* while this implementation produces only the part.
*
* \param typedb Types Database instance
* \param type RzType type
*/
RZ_API RZ_OWN char *rz_type_as_format(const RzTypeDB *typedb, RZ_NONNULL RzType *type) {
rz_return_val_if_fail(typedb && type, NULL);
if (type->kind == RZ_TYPE_KIND_CALLABLE) {
// We can't print anything useful for function type
// Thus we consider this is just a `void *` pointer
return strdup("p");
}
// Special case of callable ptr or `void *`
if (rz_type_is_void_ptr(type) || rz_type_is_callable_ptr(type)) {
return strdup("p");
}
// Special case of `char *`
if (rz_type_is_char_ptr(type)) {
return strdup("z");
}
RzStrBuf *buf = rz_strbuf_new(NULL);
type_to_format(typedb, buf, type);
return rz_strbuf_drain(buf);
}
static bool type_to_format_pair(const RzTypeDB *typedb, RzStrBuf *format, RzStrBuf *fields, RZ_NULLABLE const char *identifier, RZ_NONNULL RzType *type) {
rz_return_val_if_fail(typedb && format && fields && type, false);
if (type->kind == RZ_TYPE_KIND_IDENTIFIER) {
if (!type->identifier.name) {
return false;
}
RzBaseType *btype = rz_type_db_get_base_type(typedb, type->identifier.name);
if (!btype) {
return false;
}
base_type_to_format_unfold(typedb, btype, format, fields, identifier);
} else if (type->kind == RZ_TYPE_KIND_ARRAY) {
rz_strbuf_appendf(format, "[%" PFMT64d "]", type->array.count);
return type_to_format_pair(typedb, format, fields, identifier, type->array.type);
} else if (type->kind == RZ_TYPE_KIND_POINTER) {
// We can't print anything useful for function type pointer
if (rz_type_is_callable_ptr_nested(type)) {
// Thus we consider this is just a `void *` pointer
rz_strbuf_append(format, "p");
const char *name = rz_type_identifier(type);
// Callables are allowed to have empty names
if (name) {
rz_strbuf_appendf(fields, "%s ", name);
}
} else {
rz_strbuf_append(format, "*");
return type_to_format_pair(typedb, format, fields, identifier, type->pointer.type);
}
} else if (type->kind == RZ_TYPE_KIND_CALLABLE) {
// We can't print anything useful for function type
// Thus we consider this is just a `void *` pointer
rz_strbuf_append(format, "p");
// Callables are allowed to have empty names
if (type->callable->name) {
rz_strbuf_appendf(fields, "%s ", type->callable->name);
}
}
return true;
}
/**
* \brief Represents the RzType as a `pf` format string pair
*
* Different from the similar `rz_type_as_format` and similar
* to the `rz_base_type_as_format` since the latter shows
* the pair of .
*
* \param typedb Types Database instance
* \param type RzType type
*/
RZ_API RZ_OWN char *rz_type_as_format_pair(const RzTypeDB *typedb, RZ_NONNULL RzType *type) {
rz_return_val_if_fail(typedb && type, NULL);
RzStrBuf *format = rz_strbuf_new("");
RzStrBuf *fields = rz_strbuf_new("");
if (!type_to_format_pair(typedb, format, fields, NULL, type)) {
rz_strbuf_free(format);
rz_strbuf_free(fields);
return NULL;
}
char *fieldstr = rz_strbuf_drain(fields);
rz_strbuf_appendf(format, " %s", fieldstr);
free(fieldstr);
char *bufstr = rz_strbuf_drain(format);
rz_str_trim_tail(bufstr);
return bufstr;
}
rizin-0.7.4/librz/type/meson.build 0000664 0001750 0001750 00000002466 14731035230 016472 0 ustar sophie sophie rz_type_sources = [
'base.c',
'format.c',
'function.c',
'helpers.c',
'path.c',
'serialize_functions.c',
'serialize_types.c',
'type.c',
'typeclass.c',
'parser/c_cpp_parser.c',
'parser/types_parser.c',
'parser/types_storage.c',
]
r = run_command(py3_exe, check_meson_subproject_py, 'tree-sitter-c', check: false)
if r.returncode() == 1 and get_option('subprojects_check')
error('Subprojects are not updated. Please run `git clean -dxff subprojects/` to delete all local subprojects directories. If you want to compile against current subprojects then set option `subprojects_check=false`.')
endif
tree_sitter_c_dep = dependency('tree-sitter-c')
rz_type_inc = [
platform_inc,
'parser',
]
rz_type = library('rz_type', rz_type_sources,
include_directories: rz_type_inc,
dependencies: [
rz_util_dep,
tree_sitter_c_dep,
lrt
],
install: true,
implicit_include_directories: false,
install_rpath: rpath_lib,
soversion: rizin_libversion,
version: rizin_version,
name_suffix: lib_name_suffix,
name_prefix: lib_name_prefix,
)
rz_type_dep = declare_dependency(link_with: rz_type,
include_directories: rz_type_inc)
meson.override_dependency('rz_type', rz_type_dep)
modules += { 'rz_type': {
'target': rz_type,
'dependencies': ['rz_util']
}}
rizin-0.7.4/librz/type/parser/ 0000775 0001750 0001750 00000000000 14731035230 015614 5 ustar sophie sophie rizin-0.7.4/librz/type/parser/types_parser.h 0000664 0001750 0001750 00000012337 14731035230 020513 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
typedef struct {
size_t unions;
size_t structs;
size_t enums;
size_t callables;
} CParserAnonymousTypesState;
typedef struct {
bool verbose;
HtPP *types;
HtPP *callables;
HtPP *forward;
RzStrBuf *errors;
RzStrBuf *warnings;
RzStrBuf *debug;
CParserAnonymousTypesState anon;
} CParserState;
typedef struct {
RzBaseType *btype;
RzType *type;
} ParserTypePair;
CParserState *c_parser_state_new(HtPP *base_types, HtPP *callable_types);
void c_parser_state_free(CParserState *state);
int parse_type_nodes_save(CParserState *state, TSNode node, const char *text);
int parse_type_node_single(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, bool is_const);
int parse_declaration_node(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair);
int parse_type_descriptor_single(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair);
int parse_type_declarator_node(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, char **identifier);
int parse_type_abstract_declarator_node(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair);
void parser_debug(CParserState *state, const char *fmt, ...);
void parser_error(CParserState *state, const char *fmt, ...);
void parser_warning(CParserState *state, const char *fmt, ...);
// Types storage API
RzBaseType *c_parser_base_type_find(CParserState *state, RZ_NONNULL const char *name);
bool c_parser_base_type_is_forward_definition(CParserState *state, RZ_NONNULL const char *name);
bool c_parser_base_type_exists(CParserState *state, RZ_NONNULL const char *name);
bool c_parser_base_type_store(CParserState *state, RZ_NONNULL const char *name, ParserTypePair *tpair);
bool c_parser_forward_definition_store(CParserState *state, RZ_NONNULL const char *name);
bool c_parser_forward_definition_remove(CParserState *state, RZ_NONNULL const char *name);
RzCallable *c_parser_callable_type_find(CParserState *state, RZ_NONNULL const char *name);
bool c_parser_callable_type_exists(CParserState *state, RZ_NONNULL const char *name);
bool c_parser_callable_type_store(CParserState *state, RZ_NONNULL const char *name, RZ_NONNULL RzType *type);
RZ_OWN ParserTypePair *c_parser_new_unspecified_naked_type(CParserState *state, RZ_NONNULL const char *name, bool is_const);
RZ_OWN ParserTypePair *c_parser_new_primitive_type(CParserState *state, RZ_NONNULL const char *name, bool is_const);
RZ_OWN ParserTypePair *c_parser_get_primitive_type(CParserState *state, RZ_NONNULL const char *name, bool is_const);
RZ_OWN ParserTypePair *c_parser_new_structure_naked_type(CParserState *state, RZ_NONNULL const char *name);
RZ_OWN ParserTypePair *c_parser_new_structure_type(CParserState *state, RZ_NONNULL const char *name, size_t members_count);
RZ_OWN ParserTypePair *c_parser_get_structure_type(CParserState *state, RZ_NONNULL const char *name);
RZ_OWN ParserTypePair *c_parser_new_structure_forward_definition(CParserState *state, RZ_NONNULL const char *name);
RZ_OWN ParserTypePair *c_parser_new_union_naked_type(CParserState *state, RZ_NONNULL const char *name);
RZ_OWN ParserTypePair *c_parser_new_union_type(CParserState *state, RZ_NONNULL const char *name, size_t members_count);
RZ_OWN ParserTypePair *c_parser_get_union_type(CParserState *state, RZ_NONNULL const char *name);
RZ_OWN ParserTypePair *c_parser_new_union_forward_definition(CParserState *state, RZ_NONNULL const char *name);
RZ_OWN ParserTypePair *c_parser_new_enum_naked_type(CParserState *state, RZ_NONNULL const char *name);
RZ_OWN ParserTypePair *c_parser_new_enum_type(CParserState *state, RZ_NONNULL const char *name, size_t cases_count);
RZ_OWN ParserTypePair *c_parser_get_enum_type(CParserState *state, RZ_NONNULL const char *name);
RZ_OWN ParserTypePair *c_parser_new_enum_forward_definition(CParserState *state, RZ_NONNULL const char *name);
RZ_OWN ParserTypePair *c_parser_new_typedef(CParserState *state, RZ_NONNULL const char *name, RZ_NONNULL const char *base);
RZ_OWN ParserTypePair *c_parser_get_typedef(CParserState *state, RZ_NONNULL const char *name);
RZ_OWN RzType *c_parser_new_naked_callable(CParserState *state);
RZ_OWN RzType *c_parser_new_callable(CParserState *state, RZ_NONNULL const char *name);
bool c_parser_new_callable_argument(CParserState *state, RZ_NONNULL RzCallable *callable, RZ_NONNULL const char *name, RZ_OWN RZ_NONNULL RzType *type);
// ParserTypePair wrapper helpers
RZ_OWN ParserTypePair *c_parser_type_wrap_to_pointer(CParserState *state, ParserTypePair *tpair, bool is_const);
RZ_OWN ParserTypePair *c_parser_type_wrap_to_array(CParserState *state, ParserTypePair *tpair, size_t size);
bool c_parser_pointer_set_subtype(CParserState *state, RZ_BORROW ParserTypePair *tpair, RZ_OWN ParserTypePair *subpair);
bool c_parser_array_set_subtype(CParserState *state, RZ_BORROW ParserTypePair *tpair, RZ_OWN ParserTypePair *subpair);
// Generators of the anonymous type names
RZ_OWN char *c_parser_new_anonymous_structure_name(CParserState *state);
RZ_OWN char *c_parser_new_anonymous_union_name(CParserState *state);
RZ_OWN char *c_parser_new_anonymous_enum_name(CParserState *state);
RZ_OWN char *c_parser_new_anonymous_callable_name(CParserState *state);
rizin-0.7.4/librz/type/parser/types_parser.c 0000664 0001750 0001750 00000215311 14731035230 020503 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define TS_START_END(node, start, end) \
do { \
start = ts_node_start_byte(node); \
end = ts_node_end_byte(node); \
} while (0)
static char *ts_node_sub_string(TSNode node, const char *cstr) {
ut32 start, end;
TS_START_END(node, start, end);
return rz_str_newf("%.*s", end - start, cstr + start);
}
void node_malformed_error(CParserState *state, TSNode node, const char *text, const char *nodetype) {
rz_return_if_fail(nodetype);
char *string = ts_node_is_null(node) ? NULL : ts_node_string(node);
char *piece = ts_node_is_null(node) ? NULL : ts_node_sub_string(node, text);
rz_strbuf_appendf(state->errors, "Wrongly formed \"(%s)\": \"%s\"\n", nodetype, rz_str_get_null(string));
rz_strbuf_appendf(state->errors, "\"(%s)\": \"%s\"\n", nodetype, rz_str_get_null(piece));
free(piece);
free(string);
}
void parser_debug(CParserState *state, const char *fmt, ...) {
rz_return_if_fail(state && fmt);
if (state->verbose) {
va_list ap;
va_start(ap, fmt);
rz_strbuf_vappendf(state->debug, fmt, ap);
va_end(ap);
}
}
void parser_error(CParserState *state, const char *fmt, ...) {
rz_return_if_fail(state && fmt);
va_list ap;
va_start(ap, fmt);
rz_strbuf_vappendf(state->errors, fmt, ap);
va_end(ap);
}
void parser_warning(CParserState *state, const char *fmt, ...) {
rz_return_if_fail(state && fmt);
va_list ap;
va_start(ap, fmt);
rz_strbuf_vappendf(state->warnings, fmt, ap);
va_end(ap);
}
static bool is_abstract_declarator(const char *declarator) {
return !strcmp(declarator, "abstract_pointer_declarator") ||
!strcmp(declarator, "abstract_array_declarator") ||
!strcmp(declarator, "abstract_function_declarator");
}
static bool is_declarator(const char *declarator) {
return !strcmp(declarator, "pointer_declarator") ||
!strcmp(declarator, "array_declarator") ||
!strcmp(declarator, "function_declarator") ||
!strcmp(declarator, "identifier") ||
!strcmp(declarator, "field_identifier");
}
static bool is_function_declarator(const char *declarator) {
return !strcmp(declarator, "parenthesized_declarator") ||
!strcmp(declarator, "identifier");
}
static bool is_bitfield_clause(const char *name) {
return !strcmp(name, "bitfield_clause");
}
static bool is_type_declarator(const char *declarator) {
return !strcmp(declarator, "pointer_declarator") ||
!strcmp(declarator, "array_declarator") ||
!strcmp(declarator, "function_declarator") ||
!strcmp(declarator, "type_identifier");
}
// Parses primitive type - like "int", "char", "size_t"
int parse_primitive_type(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, bool is_const) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
rz_return_val_if_fail(ts_node_is_named(node), -1);
parser_debug(state, "parse_primitive_type(): %s\n", is_const ? "const" : "not const");
if (strcmp(ts_node_type(node), "primitive_type")) {
node_malformed_error(state, node, text, "not primitive type");
return -1;
}
char *real_type = ts_node_sub_string(node, text);
if (!real_type) {
node_malformed_error(state, node, text, "primitive type");
parser_error(state, "Primitive type name cannot be NULL\n");
return -1;
}
// At first we search if the type is already presented in the state
if ((*tpair = c_parser_get_primitive_type(state, real_type, is_const))) {
parser_debug(state, "Fetched primitive type: \"%s\"\n", real_type);
free(real_type);
return 0;
}
// If not - we form both RzType and RzBaseType to store in the Types database
ParserTypePair *type_pair = c_parser_new_primitive_type(state, real_type, is_const);
if (!type_pair) {
parser_error(state, "Error forming RzType and RzBaseType pair out of primitive type\n");
free(real_type);
return -1;
}
c_parser_base_type_store(state, real_type, type_pair);
*tpair = type_pair;
free(real_type);
return 0;
}
// Parses sized primitive type - like "long int", "unsigned char", "short", "unsigned long long", etc
int parse_sized_primitive_type(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, bool is_const) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
rz_return_val_if_fail(ts_node_is_named(node), -1);
if (strcmp(ts_node_type(node), "sized_type_specifier")) {
node_malformed_error(state, node, text, "not sized primitive type");
return -1;
}
char *real_type = ts_node_sub_string(node, text);
if (!real_type) {
node_malformed_error(state, node, text, "primitive type");
parser_error(state, "Primitive type name cannot be NULL\n");
free(real_type);
return -1;
}
// At first we search if the type is already presented in the state
if ((*tpair = c_parser_get_primitive_type(state, real_type, is_const))) {
parser_debug(state, "Fetched primitive type: \"%s\"\n", real_type);
free(real_type);
return 0;
}
// If not - we form both RzType and RzBaseType to store in the Types database
ParserTypePair *type_pair = c_parser_new_primitive_type(state, real_type, is_const);
if (!type_pair) {
parser_error(state, "Error forming RzType and RzBaseType pair out of primitive type\n");
free(real_type);
return -1;
}
c_parser_base_type_store(state, real_type, type_pair);
*tpair = type_pair;
free(real_type);
return 0;
}
// Parses primitive type or type alias mention - like "socklen_t", etc
int parse_sole_type_name(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, bool is_const) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
rz_return_val_if_fail(ts_node_is_named(node), -1);
if (strcmp(ts_node_type(node), "type_identifier")) {
node_malformed_error(state, node, text, "just a type name");
return -1;
}
char *real_type = ts_node_sub_string(node, text);
// At first we search if the type is already presented in the state and is a primitive one
if ((*tpair = c_parser_get_primitive_type(state, real_type, is_const))) {
parser_debug(state, "Fetched type: \"%s\"\n", real_type);
free(real_type);
return 0;
}
// After that we search if the type is already presented in the state and is a type alias
if ((*tpair = c_parser_get_typedef(state, real_type))) {
parser_debug(state, "Fetched type: \"%s\"\n", real_type);
free(real_type);
return 0;
}
// Then we check if the type is already forward-defined
if (c_parser_base_type_is_forward_definition(state, real_type)) {
parser_debug(state, "Already has forward definition of type: \"%s\"\n", real_type);
*tpair = c_parser_new_unspecified_naked_type(state, real_type, is_const);
if (!*tpair) {
parser_error(state, "Error forming naked RzType pair out of simple forward-looking type: \"%s\"\n", real_type);
free(real_type);
return -1;
}
free(real_type);
return 0;
}
// Before resorting to create a new forward type, check if there is some union or struct with the same name already.
// This will e.g. catch cases like referring to `struct MyStruct` by just `MyStruct`.
if ((*tpair = c_parser_get_structure_type(state, real_type))) {
parser_debug(state, "Fetched type as struct: \"%s\"\n", real_type);
free(real_type);
return 0;
}
if ((*tpair = c_parser_get_union_type(state, real_type))) {
parser_debug(state, "Fetched type as union: \"%s\"\n", real_type);
free(real_type);
return 0;
}
// If not - we form both RzType and RzBaseType to store in the Types database
// as a forward-looking definition
*tpair = c_parser_new_primitive_type(state, real_type, is_const);
if (!*tpair) {
parser_error(state, "Error forming RzType and RzBaseType pair out of simple forward-looking type\n");
free(real_type);
return -1;
}
// Do allow forward-looking definitions we just add the type into the forward hashtable
if (c_parser_forward_definition_store(state, real_type)) {
parser_debug(state, "Added forward definition of type: \"%s\"\n", real_type);
rz_type_base_type_free((*tpair)->btype);
(*tpair)->btype = NULL;
free(real_type);
return 0;
}
rz_type_free((*tpair)->type);
rz_type_base_type_free((*tpair)->btype);
RZ_FREE(*tpair);
free(real_type);
return -1;
}
// Parses parameter declarations - they are part of the parameter list, e.g.
// in the function definition/type as arguments
int parse_parameter_declaration_node(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, char **identifier) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
rz_return_val_if_fail(ts_node_is_named(node), -1);
const char *param_type = ts_node_type(node);
parser_debug(state, "parameter type: %s\n", param_type);
// Type descriptor has three fields:
// 0. type qualifier (optional)
// 1. type itself (optional)
// 2. declarator (can be concrete or an abstract one)
// Parse the type qualifier first (if present)
// FIXME: There could be multiple different type qualifiers in one declaration
bool is_const = false;
TSNode first_leaf = ts_node_named_child(node, 0);
if (!ts_node_is_null(first_leaf)) {
const char *leaf_type = ts_node_type(first_leaf);
// If we have type qualifier in this position it is related to
// the type itself
if (!strcmp(leaf_type, "type_qualifier")) {
char *qualifier = ts_node_sub_string(first_leaf, text);
parser_debug(state, "has qualifier %s\n", qualifier);
if (!strcmp(qualifier, "const")) {
is_const = true;
}
free(qualifier);
}
}
// Ever parameter should have at least type field
TSNode parameter_type = ts_node_child_by_field_name(node, "type", 4);
if (ts_node_is_null(parameter_type)) {
parser_error(state, "ERROR: Parameter AST should contain at least one node!\n");
node_malformed_error(state, node, text, "parameter type");
return -1;
}
if (parse_type_node_single(state, parameter_type, text, tpair, is_const)) {
parser_error(state, "Cannot parse type_descriptor's type field");
return -1;
}
if (!*tpair) {
parser_error(state, "Failed to parse type_descriptor's type field");
return -1;
}
// Ever parameter could have a declarator field but it's optional
TSNode parameter_declarator = ts_node_child_by_field_name(node, "declarator", 10);
if (ts_node_is_null(parameter_declarator)) {
// In the case it's null it means the sole type name which was
// already parsed in "parse_type_node_single()"
return 0;
}
// Check if it's abstract or a concrete node
const char *declarator_type = ts_node_type(parameter_declarator);
if (!declarator_type) {
node_malformed_error(state, parameter_declarator, text, "parameter declarator");
return -1;
}
parser_debug(state, "declarator type: \"%s\"\n", declarator_type);
if (is_abstract_declarator(declarator_type)) {
return parse_type_abstract_declarator_node(state, parameter_declarator, text, tpair);
} else if (is_declarator(declarator_type)) {
return parse_type_declarator_node(state, parameter_declarator, text, tpair, identifier);
}
node_malformed_error(state, parameter_declarator, text, "parameter declarator");
return -1;
}
// Types can be
// - struct (struct_specifier)
// - union (union_specifier)
// - enum (enum_specifier) (usually prepended by declaration)
// - typedef (type_definition)
// - atomic type (primitive_type)
// Parses the struct definitions - concrete or an abstract ones
int parse_struct_node(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, bool is_const) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
rz_return_val_if_fail(ts_node_is_named(node), -1);
parser_debug(state, "parse_struct_node()\n");
int struct_node_child_count = ts_node_named_child_count(node);
if (struct_node_child_count < 1 || struct_node_child_count > 3) {
node_malformed_error(state, node, text, "struct");
return -1;
}
int result = 0;
// Name is optional, in abstract definitions or as the member of nested types
char *name = NULL;
TSNode struct_name = ts_node_child_by_field_name(node, "name", 4);
if (ts_node_is_null(struct_name)) {
parser_debug(state, "Anonymous struct\n");
name = c_parser_new_anonymous_structure_name(state);
} else {
name = ts_node_sub_string(struct_name, text);
if (!name) {
parser_error(state, "ERROR: Struct name should not be NULL!\n");
node_malformed_error(state, node, text, "struct");
return -1;
}
parser_debug(state, "struct name: %s\n", name);
}
// Parsing the structure body
// If the structure doesn't have body but has a name
// it means that it uses the type predefined before
// e.g. "const struct tm* a;"
TSNode struct_body = ts_node_child_by_field_name(node, "body", 4);
if (ts_node_is_null(struct_body) && !ts_node_is_null(struct_name)) {
parser_debug(state, "Fetching predefined structure: \"%s\"\n", name);
if (!(*tpair = c_parser_get_structure_type(state, name))) {
parser_warning(state, "Cannot find \"%s\" structure in the context\n", name);
// At first we check if there is a forward definion already
if (c_parser_base_type_is_forward_definition(state, name)) {
parser_debug(state, "Structure \"%s\" was forward-defined before\n", name);
if (!(*tpair = c_parser_new_structure_naked_type(state, name))) {
parser_error(state, "Cannot create \"%s\" naked structure type in the context\n", name);
result = -1;
goto snexit;
}
goto snexit;
}
// We still could create the "forward looking struct declaration"
// The parser then can augment the definition
if (!(*tpair = c_parser_new_structure_forward_definition(state, name))) {
parser_error(state, "Cannot create \"%s\" forward structure definition in the context\n", name);
result = -1;
goto snexit;
}
goto snexit;
} else {
goto snexit;
}
}
// If it's the type definition - we proceed further
int body_child_count = ts_node_named_child_count(struct_body);
// Structures could lack BOTH name and body, e.g. as a member of another struct:
// struct a {
// struct {} b;
// }
// Now we form both RzType and RzBaseType to store in the Types database
ParserTypePair *struct_pair = c_parser_new_structure_type(state, name, body_child_count);
if (!struct_pair) {
parser_error(state, "Error forming RzType and RzBaseType pair out of struct: \"%s\"\n", name);
result = -1;
goto snexit;
}
char *real_type = NULL;
char *real_identifier = NULL;
int i;
for (i = 0; i < body_child_count; i++) {
parser_debug(state, "struct: processing %d field...\n", i);
TSNode child = ts_node_named_child(struct_body, i);
const char *node_type = ts_node_type(child);
// Skip comments
if (!strcmp(node_type, "comment")) {
continue;
}
// Parse the type qualifier first (if present)
// FIXME: There could be multiple different type qualifiers in one declaration
bool is_const = false;
TSNode first_leaf = ts_node_named_child(child, 0);
if (ts_node_is_null(first_leaf)) {
node_malformed_error(state, child, text, "field_declaration");
result = -1;
goto srnexit;
}
const char *leaf_type = ts_node_type(first_leaf);
// If we have type qualifier in this position it is related to
// the declarator itself, not the type, e.g. constant pointer,
// not pointer to the constant
if (!strcmp(leaf_type, "type_qualifier")) {
char *qualifier = ts_node_sub_string(first_leaf, text);
parser_debug(state, "has qualifier %s\n", qualifier);
if (!strcmp(qualifier, "const")) {
is_const = true;
}
free(qualifier);
}
// Every field should have (field_declaration) AST clause
if (strcmp(node_type, "field_declaration")) {
parser_error(state, "ERROR: Struct field AST should contain (field_declaration) node!\n");
node_malformed_error(state, child, text, "struct field");
result = -1;
goto srnexit;
}
// Every field node should have type and at least one declarator:
TSNode field_type = ts_node_child_by_field_name(child, "type", 4);
if (ts_node_is_null(field_type)) {
parser_error(state, "ERROR: Struct field AST should contain type");
node_malformed_error(state, child, text, "struct field");
result = -1;
goto srnexit;
}
// Every field can be:
// - atomic: "int a;" or "char b[20]"
// - bitfield: int a:7;"
// - nested: "struct { ... } a;" or "union { ... } a;"
// - all these but with multiple declarators in one line
if (state->verbose) {
char *fieldtext = ts_node_sub_string(child, text);
char *nodeast = ts_node_string(child);
if (fieldtext && nodeast) {
parser_debug(state, "field text: %s\n", fieldtext);
parser_debug(state, "field ast: %s\n", nodeast);
}
free(fieldtext);
free(nodeast);
}
// Parse types first
free(real_type);
real_type = ts_node_sub_string(field_type, text);
if (!real_type) {
parser_error(state, "ERROR: Struct member type should not be NULL!\n");
node_malformed_error(state, child, text, "struct field");
result = -1;
goto srnexit;
}
ParserTypePair *membtpair = NULL;
// At first, we parse the type field
if (parse_type_node_single(state, field_type, text, &membtpair, is_const)) {
parser_error(state, "ERROR: parsing struct member type\n");
node_malformed_error(state, child, text, "struct field");
result = -1;
goto srnexit;
}
TSNode field_declarator = ts_node_child_by_field_name(child, "declarator", 10);
if (ts_node_is_null(field_declarator)) {
parser_error(state, "ERROR: Struct field AST should contain at least one declarator item");
node_malformed_error(state, child, text, "struct field");
result = -1;
goto srnexit;
}
// We could have multiple declarator members of the same type
do {
// First we extract the identifier
free(real_identifier);
real_identifier = ts_node_sub_string(field_declarator, text);
if (!real_identifier) {
parser_error(state, "ERROR: Struct declarator should not be NULL!\n");
node_malformed_error(state, child, text, "struct field");
result = -1;
goto srnexit;
}
parser_debug(state, "field type: %s field_declarator: %s\n", real_type, real_identifier);
// 1st case, bitfield
// AST looks like
// type: (primitive_type) declarator: (field_identifier) (bitfield_clause (number_literal))
// or type: (primitive_type) declarator: (...) declarator (...)
// If it has the additional node after the declarator - it's bitfield
TSNode next_sibling = ts_node_next_named_sibling(field_declarator);
if (!ts_node_is_null(next_sibling) && is_bitfield_clause(ts_node_type(next_sibling))) {
const char *bfnode_type = ts_node_type(field_type);
// As per C standard bitfields are defined only for atomic types, particularly "int"
if (strcmp(bfnode_type, "primitive_type") && strcmp(bfnode_type, "type_identifier")) {
parser_error(state, "ERROR: Struct bitfield cannot contain non-primitive bitfield!\n");
node_malformed_error(state, child, text, "struct field");
result = -1;
goto srnexit;
}
if (ts_node_named_child_count(next_sibling) < 1) {
node_malformed_error(state, child, text, "struct field");
result = -1;
goto srnexit;
}
TSNode field_bits = ts_node_named_child(next_sibling, 0);
if (ts_node_is_null(field_bits)) {
parser_error(state, "ERROR: Struct bitfield bits AST node should not be NULL!\n");
node_malformed_error(state, child, text, "struct field");
result = -1;
goto srnexit;
}
const char *bits_str = ts_node_sub_string(field_bits, text);
int bits = rz_num_get(NULL, bits_str);
parser_debug(state, "field type: %s field_identifier: %s bits: %d\n", real_type, real_identifier, bits);
// Then we augment resulting type field with the data from parsed declarator
char *membname = NULL;
if (parse_type_declarator_node(state, field_declarator, text, &membtpair, &membname)) {
parser_error(state, "ERROR: parsing bitfield struct member declarator\n");
node_malformed_error(state, child, text, "struct field");
result = -1;
goto srnexit;
}
// Add a struct member
RzVector *members = &struct_pair->btype->struct_data.members;
RzTypeStructMember memb = {
.name = membname,
.type = rz_type_clone(membtpair->type),
.offset = 0, // FIXME
.size = 0, // FIXME
};
void *element = rz_vector_push(members, &memb); // returns null if no space available
if (!element) {
parser_error(state, "Error appending bitfield struct member to the base type\n");
result = -1;
goto srnexit;
}
} else if (is_declarator(ts_node_type(field_declarator))) {
// 2nd case, normal structure
// AST looks like
// type: (primitive_type) declarator: (field_identifier)
// or type: (primitive_type) declarator: (...) declarator (...)
// Augment resulting type field with the data from parsed declarator
char *membname = NULL;
if (parse_type_declarator_node(state, field_declarator, text, &membtpair, &membname)) {
parser_error(state, "ERROR: parsing struct member declarator\n");
node_malformed_error(state, child, text, "struct field");
result = -1;
goto srnexit;
}
// Add a struct member
RzVector *members = &struct_pair->btype->struct_data.members;
RzTypeStructMember memb = {
.name = membname,
.type = rz_type_clone(membtpair->type),
.offset = 0, // FIXME
.size = 0, // FIXME
};
void *element = rz_vector_push(members, &memb); // returns null if no space available
if (!element) {
parser_error(state, "Error appending struct member to the base type\n");
result = -1;
goto srnexit;
}
parser_debug(state, "Appended member \"%s\" into struct \"%s\"\n", membname, name);
} else {
parser_debug(state, "Struct field wrong: \"%s\"\n", ts_node_sub_string(field_declarator, text));
}
field_declarator = ts_node_next_named_sibling(field_declarator);
} while (!ts_node_is_null(field_declarator));
free(membtpair);
}
// If parsing successfull completed - we store the state
if (struct_pair) {
c_parser_base_type_store(state, name, struct_pair);
// If it was a forward definition previously - remove it
if (c_parser_base_type_is_forward_definition(state, name)) {
c_parser_forward_definition_remove(state, name);
}
}
*tpair = struct_pair;
srnexit:
free(real_type);
free(real_identifier);
snexit:
free(name);
return result;
}
// Parses the union definitions - concrete or an abstract ones
// Quite similar to structures but the size and offset calculation is different
int parse_union_node(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, bool is_const) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
rz_return_val_if_fail(ts_node_is_named(node), -1);
parser_debug(state, "parse_union_node()\n");
int union_node_child_count = ts_node_named_child_count(node);
if (union_node_child_count < 1 || union_node_child_count > 2) {
node_malformed_error(state, node, text, "union");
return -1;
}
int result = 0;
// Name is optional, in abstract definitions or as the member of nested types
char *name = NULL;
TSNode union_name = ts_node_child_by_field_name(node, "name", 4);
if (ts_node_is_null(union_name)) {
parser_debug(state, "Anonymous union\n");
name = c_parser_new_anonymous_union_name(state);
} else {
name = ts_node_sub_string(union_name, text);
if (!name) {
parser_error(state, "ERROR: Union name should not be NULL!\n");
node_malformed_error(state, node, text, "union");
return -1;
}
parser_debug(state, "union name: %s\n", name);
}
// Parsing the union body
// If the union doesn't have body but has a name
// it means that it uses the type predefined before
// e.g. "const union tm* a;"
TSNode union_body = ts_node_child_by_field_name(node, "body", 4);
if (ts_node_is_null(union_body) && !ts_node_is_null(union_name)) {
parser_debug(state, "Fetching predefined union: \"%s\"\n", name);
if (!(*tpair = c_parser_get_union_type(state, name))) {
parser_warning(state, "Cannot find \"%s\" union in the context\n", name);
// At first we check if there is a forward definion already
if (c_parser_base_type_is_forward_definition(state, name)) {
parser_debug(state, "Union \"%s\" was forward-defined before\n", name);
if (!(*tpair = c_parser_new_union_naked_type(state, name))) {
parser_error(state, "Cannot create \"%s\" naked union type in the context\n", name);
result = -1;
goto unexit;
}
goto unexit;
}
// We still could create the "forward looking union declaration"
// The parser then can augment the definition
if (!(*tpair = c_parser_new_union_forward_definition(state, name))) {
parser_error(state, "Cannot create \"%s\" forward union definition in the context\n", name);
result = -1;
goto unexit;
}
goto unexit;
} else {
goto unexit;
}
}
// If it's the type definition - we proceed further
int body_child_count = ts_node_named_child_count(union_body);
// Unions could lack BOTH name and body, e.g. as a member of another struct or union:
// struct a {
// union {} b;
// }
// Now we form both RzType and RzBaseType to store in the Types database
ParserTypePair *union_pair = c_parser_new_union_type(state, name, body_child_count);
if (!union_pair) {
parser_error(state, "Error forming RzType and RzBaseType pair out of union\n");
return -1;
}
char *real_type = NULL;
char *real_identifier = NULL;
int i;
for (i = 0; i < body_child_count; i++) {
parser_debug(state, "union: processing %d field...\n", i);
TSNode child = ts_node_named_child(union_body, i);
const char *node_type = ts_node_type(child);
// Skip comments
if (!strcmp(node_type, "comment")) {
continue;
}
// Parse the type qualifier first (if present)
// FIXME: There could be multiple different type qualifiers in one declaration
bool is_const = false;
TSNode first_leaf = ts_node_named_child(child, 0);
if (ts_node_is_null(first_leaf)) {
node_malformed_error(state, child, text, "field_declaration");
result = -1;
goto urnexit;
}
const char *leaf_type = ts_node_type(first_leaf);
// If we have type qualifier in this position it is related to
// the declarator itself, not the type, e.g. constant pointer,
// not pointer to the constant
if (!strcmp(leaf_type, "type_qualifier")) {
char *qualifier = ts_node_sub_string(first_leaf, text);
parser_debug(state, "has qualifier %s\n", qualifier);
if (!strcmp(qualifier, "const")) {
is_const = true;
}
free(qualifier);
}
// Every field should have (field_declaration) AST clause
if (strcmp(node_type, "field_declaration")) {
parser_error(state, "ERROR: Union field AST should contain (field_declaration) node!\n");
node_malformed_error(state, child, text, "union field");
result = -1;
goto urnexit;
}
// Every field node should have at least type and declarator:
TSNode field_type = ts_node_child_by_field_name(child, "type", 4);
if (ts_node_is_null(field_type)) {
parser_error(state, "ERROR: Union field AST shoudl contain type");
node_malformed_error(state, child, text, "union field");
result = -1;
goto urnexit;
}
// Every field can be:
// - atomic: "int a;" or "char b[20]"
// - bitfield: int a:7;"
// - nested: "struct { ... } a;" or "union { ... } a;"
if (state->verbose) {
char *fieldtext = ts_node_sub_string(child, text);
char *nodeast = ts_node_string(child);
if (fieldtext && nodeast) {
parser_debug(state, "field text: %s\n", fieldtext);
parser_debug(state, "field ast: %s\n", nodeast);
}
free(fieldtext);
free(nodeast);
}
// Parse types first
free(real_type);
real_type = ts_node_sub_string(field_type, text);
if (!real_type) {
parser_error(state, "ERROR: Union bitfield type should not be NULL!\n");
node_malformed_error(state, child, text, "union field");
result = -1;
goto urnexit;
}
ParserTypePair *membtpair = NULL;
// At first, we parse the type field
if (parse_type_node_single(state, field_type, text, &membtpair, is_const)) {
parser_error(state, "ERROR: parsing union member type\n");
node_malformed_error(state, child, text, "union field");
result = -1;
goto urnexit;
}
TSNode field_declarator = ts_node_child_by_field_name(child, "declarator", 10);
if (ts_node_is_null(field_declarator)) {
parser_error(state, "ERROR: Union field AST should contain at least one declarator item");
node_malformed_error(state, child, text, "union field");
result = -1;
goto urnexit;
}
// We could have multiple declarator members of the same type
do {
// First we extract the identifier
free(real_identifier);
real_identifier = ts_node_sub_string(field_declarator, text);
if (!real_identifier) {
parser_error(state, "ERROR: Union declarator should not be NULL!\n");
node_malformed_error(state, child, text, "union field");
result = -1;
goto urnexit;
}
parser_debug(state, "field type: %s field_declarator: %s\n", real_type, real_identifier);
// 1st case, bitfield
// AST looks like
// type: (primitive_type) declarator: (field_identifier) (bitfield_clause (number_literal))
// Thus it has the additional node after the declarator
TSNode next_sibling = ts_node_next_named_sibling(field_declarator);
if (!ts_node_is_null(next_sibling) && is_bitfield_clause(ts_node_type(next_sibling))) {
const char *bfnode_type = ts_node_type(field_type);
// As per C standard bitfields are defined only for atomic types, particularly "int"
if (strcmp(bfnode_type, "primitive_type") && strcmp(bfnode_type, "type_identifier")) {
parser_error(state, "ERROR: Union bitfield cannot contain non-primitive bitfield!\n");
node_malformed_error(state, child, text, "union field");
result = -1;
goto urnexit;
}
if (ts_node_named_child_count(next_sibling) != 1) {
node_malformed_error(state, child, text, "union field");
result = -1;
goto urnexit;
}
TSNode field_bits = ts_node_named_child(next_sibling, 0);
if (ts_node_is_null(field_bits)) {
parser_error(state, "ERROR: Union bitfield bits AST node should not be NULL!\n");
node_malformed_error(state, child, text, "union field");
result = -1;
goto urnexit;
}
const char *bits_str = ts_node_sub_string(field_bits, text);
int bits = rz_num_get(NULL, bits_str);
parser_debug(state, "field type: %s field_identifier: %s bits: %d\n", real_type, real_identifier, bits);
// Then we augment resulting type field with the data from parsed declarator
char *membname = NULL;
if (parse_type_declarator_node(state, field_declarator, text, &membtpair, &membname)) {
parser_error(state, "ERROR: parsing union member declarator\n");
node_malformed_error(state, child, text, "union field");
result = -1;
goto urnexit;
}
// Add a union member
RzVector *members = &union_pair->btype->union_data.members;
RzTypeUnionMember memb = {
.name = membname,
.type = rz_type_clone(membtpair->type),
.offset = 0, // Always 0 for unions
.size = 0, // FIXME
};
void *element = rz_vector_push(members, &memb); // returns null if no space available
if (!element) {
parser_error(state, "Error appending union member to the base type\n");
result = -1;
goto urnexit;
}
} else if (is_declarator(ts_node_type(field_declarator))) {
// 2nd case, normal union
// AST looks like
// type: (primitive_type) declarator: (field_identifier)
// Then we augment resulting type field with the data from parsed declarator
char *membname = NULL;
if (parse_type_declarator_node(state, field_declarator, text, &membtpair, &membname)) {
parser_error(state, "ERROR: parsing union member declarator\n");
node_malformed_error(state, child, text, "union field");
result = -1;
goto urnexit;
}
// Add a union member
RzVector *members = &union_pair->btype->union_data.members;
RzTypeUnionMember memb = {
.name = membname,
.type = rz_type_clone(membtpair->type),
.offset = 0, // Always 0 for unions
.size = 0, // FIXME
};
void *element = rz_vector_push(members, &memb); // returns null if no space available
if (!element) {
parser_error(state, "Error appending union member to the base type\n");
result = -1;
goto urnexit;
}
parser_debug(state, "Appended member \"%s\" into union \"%s\"\n", membname, name);
}
field_declarator = ts_node_next_named_sibling(field_declarator);
} while (!ts_node_is_null(field_declarator));
free(membtpair);
}
// If parsing successfull completed - we store the state
if (union_pair) {
c_parser_base_type_store(state, name, union_pair);
// If it was a forward definition previously - remove it
if (c_parser_base_type_is_forward_definition(state, name)) {
c_parser_forward_definition_remove(state, name);
}
}
*tpair = union_pair;
urnexit:
free(real_type);
free(real_identifier);
unexit:
free(name);
return result;
}
// Parsing enum definitions - concrete and abstract ones
int parse_enum_node(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, bool is_const) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
rz_return_val_if_fail(ts_node_is_named(node), -1);
parser_debug(state, "parse_enum_node()\n");
int enum_node_child_count = ts_node_named_child_count(node);
// Possible nodes are "name", "underlying_type", "body"
if (enum_node_child_count < 1 || enum_node_child_count > 3) {
node_malformed_error(state, node, text, "enum");
return -1;
}
int result = 0;
// Name is optional, in abstract definitions or as the member of nested types
char *name = NULL;
TSNode enum_name = ts_node_child_by_field_name(node, "name", 4);
if (ts_node_is_null(enum_name)) {
parser_debug(state, "Anonymous enum\n");
name = c_parser_new_anonymous_enum_name(state);
} else {
name = ts_node_sub_string(enum_name, text);
if (!name) {
parser_error(state, "ERROR: Enum name should not be NULL!\n");
node_malformed_error(state, node, text, "enum");
return -1;
}
parser_debug(state, "enum name: %s\n", name);
}
// Parsing the enum body
// If the enum doesn't have body but has a name
// it means that it uses the type predefined before
// e.g. "const enum FOO a;"
TSNode enum_body = ts_node_child_by_field_name(node, "body", 4);
if (ts_node_is_null(enum_body) && !ts_node_is_null(enum_name)) {
parser_debug(state, "Fetching predefined enum: \"%s\"\n", name);
if (!(*tpair = c_parser_get_enum_type(state, name))) {
parser_warning(state, "Cannot find \"%s\" enum in the context\n", name);
// At first we check if there is a forward definion already
if (c_parser_base_type_is_forward_definition(state, name)) {
parser_debug(state, "Enum \"%s\" was forward-defined before\n", name);
if (!(*tpair = c_parser_new_enum_naked_type(state, name))) {
parser_error(state, "Cannot create \"%s\" naked enum type in the context\n", name);
result = -1;
goto rexit;
}
goto rexit;
}
// We still could create the "forward looking enum declaration"
// The parser then can augment the definition
if (!(*tpair = c_parser_new_enum_forward_definition(state, name))) {
parser_error(state, "Cannot create \"%s\" forward enum definition in the context\n", name);
result = -1;
goto rexit;
}
goto rexit;
} else {
goto rexit;
}
}
parser_debug(state, "enum name: %s\n", name);
int body_child_count = ts_node_named_child_count(enum_body);
// Now we form both RzType and RzBaseType to store in the Types database
ParserTypePair *enum_pair = c_parser_new_enum_type(state, name, body_child_count);
if (!enum_pair) {
parser_error(state, "Error forming RzType and RzBaseType pair out of enum: \"%s\"\n", name);
result = -1;
goto rexit;
}
// Then we process all enumeration cases and add one by one
int i;
for (i = 0; i < body_child_count; i++) {
parser_debug(state, "enum: processing %d field...\n", i);
TSNode child = ts_node_named_child(enum_body, i);
const char *node_type = ts_node_type(child);
// Skip comments
if (!strcmp(node_type, "comment")) {
continue;
}
// Every field should have (field_declaration) AST clause
if (strcmp(node_type, "enumerator")) {
parser_error(state, "ERROR: Enum member AST should contain (enumerator) node!\n");
node_malformed_error(state, child, text, "enum field");
free(enum_pair);
result = -1;
goto rexit;
}
// Every member node should have at least 1 child!
int member_child_count = ts_node_named_child_count(child);
if (member_child_count < 1 || member_child_count > 2) {
parser_error(state, "ERROR: enum member AST cannot contain less than 1 or more than 2 items");
node_malformed_error(state, child, text, "enum field");
free(enum_pair);
result = -1;
goto rexit;
}
// Every member can be:
// - empty
// - atomic: "1"
// - expression: "1 << 2"
if (state->verbose) {
char *membertext = ts_node_sub_string(child, text);
char *nodeast = ts_node_string(child);
if (membertext && nodeast) {
parser_debug(state, "member text: %s\n", membertext);
parser_debug(state, "member ast: %s\n", nodeast);
}
free(nodeast);
free(membertext);
}
if (member_child_count == 1) {
// It's an empty field, like just "A,"
TSNode member_identifier = ts_node_child_by_field_name(child, "name", 4);
if (ts_node_is_null(member_identifier)) {
parser_error(state, "ERROR: Enum case identifier should not be NULL!\n");
node_malformed_error(state, child, text, "enum case");
free(enum_pair);
result = -1;
goto rexit;
}
char *real_identifier = ts_node_sub_string(member_identifier, text);
parser_debug(state, "enum member: %s\n", real_identifier);
// Add an enum case
RzVector *cases = &enum_pair->btype->enum_data.cases;
// In this case we just increment previous value by 1
st64 derived_val = 0;
if (!rz_vector_empty(cases)) {
RzTypeEnumCase *lastcase = rz_vector_tail(cases);
derived_val = lastcase->val + 1;
}
RzTypeEnumCase cas = {
.name = real_identifier,
.val = derived_val
};
void *element = rz_vector_push(cases, &cas); // returns null if no space available
if (!element) {
parser_error(state, "Error appending enum case to the base type\n");
free(cas.name);
free(enum_pair);
result = -1;
goto rexit;
}
} else {
// It's a proper field, like "A = 1,"
TSNode member_identifier = ts_node_child_by_field_name(child, "name", 4);
TSNode member_value = ts_node_child_by_field_name(child, "value", 5);
if (ts_node_is_null(member_identifier) || ts_node_is_null(member_value)) {
parser_error(state, "ERROR: Enum case identifier and value should not be NULL!\n");
node_malformed_error(state, child, text, "enum case");
free(enum_pair);
result = -1;
goto rexit;
}
char *real_identifier = ts_node_sub_string(member_identifier, text);
char *real_value = ts_node_sub_string(member_value, text);
// FIXME: Use RzNum to calculate complex expressions
parser_debug(state, "enum member: %s value: %s\n", real_identifier, real_value);
// Add an enum case
RzVector *cases = &enum_pair->btype->enum_data.cases;
RzTypeEnumCase cas = {
.name = real_identifier,
.val = rz_num_get(NULL, real_value)
};
free(real_value);
void *element = rz_vector_push(cases, &cas); // returns null if no space available
if (!element) {
parser_error(state, "Error appending enum case to the base type\n");
free(cas.name);
free(enum_pair);
result = -1;
goto rexit;
}
}
}
// If parsing successfull completed - we store the state
if (enum_pair) {
c_parser_base_type_store(state, name, enum_pair);
// If it was a forward definition previously - remove it
if (c_parser_base_type_is_forward_definition(state, name)) {
c_parser_forward_definition_remove(state, name);
}
}
*tpair = enum_pair;
rexit:
free(name);
return result;
}
// Parsing typedefs - these are ALWAYS concrete due to the syntax specifics
int parse_typedef_node(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
rz_return_val_if_fail(ts_node_is_named(node), -1);
parser_debug(state, "parse_typedef_node()\n");
int typedef_node_child_count = ts_node_named_child_count(node);
if (typedef_node_child_count < 2) {
node_malformed_error(state, node, text, "typedef");
return -1;
}
// Parse the type qualifier first
// FIXME: There could be multiple different type qualifiers in one declaration
bool is_const = false;
TSNode first_leaf = ts_node_named_child(node, 0);
if (ts_node_is_null(first_leaf)) {
node_malformed_error(state, node, text, "typedef");
return -1;
}
const char *leaf_type = ts_node_type(first_leaf);
if (!strcmp(leaf_type, "type_qualifier")) {
char *qualifier = ts_node_sub_string(first_leaf, text);
parser_debug(state, "has qualifier %s\n", qualifier);
if (!strcmp(qualifier, "const")) {
is_const = true;
}
free(qualifier);
}
TSNode typedef_type = ts_node_child_by_field_name(node, "type", 4);
if (ts_node_is_null(typedef_type)) {
parser_error(state, "ERROR: Typedef type node should not be NULL!\n");
node_malformed_error(state, node, text, "typedef");
return -1;
}
// Every typedef type can be:
// - atomic: "int", "uint64_t", etc
// - some type name - any identificator
// - complex type like struct, union, or enum
if (state->verbose) {
char *typetext = ts_node_sub_string(typedef_type, text);
char *nodeast = ts_node_string(typedef_type);
if (typetext && nodeast) {
parser_debug(state, "type text: %s\n", typetext);
parser_debug(state, "type ast: %s\n", nodeast);
}
free(typetext);
free(nodeast);
}
ParserTypePair *type_pair = NULL;
if (parse_type_node_single(state, typedef_type, text, &type_pair, is_const)) {
parser_error(state, "ERROR: parsing typedef type identifier\n");
node_malformed_error(state, typedef_type, text, "typedef type");
return -1;
}
// Every typedef node could have multiple declarators
TSNode typedef_declarator = ts_node_child_by_field_name(node, "declarator", 10);
if (ts_node_is_null(typedef_declarator)) {
parser_error(state, "ERROR: Typedef should have at least one declarator node!\n");
node_malformed_error(state, node, text, "typedef");
return -1;
}
do {
// Then we augment resulting type field with the data from parsed declarator
char *typedef_name = NULL;
if (parse_type_declarator_node(state, typedef_declarator, text, &type_pair, &typedef_name)) {
parser_error(state, "ERROR: parsing typedef declarator\n");
node_malformed_error(state, typedef_declarator, text, "typedef declarator");
return -1;
}
// Now we form both RzType and RzBaseType to store in the Types database
// Note, that if base type is NULL then it's forward definition and we should
// use the RzType identifier instead;
const char *base_type_name = rz_type_identifier(type_pair->type);
parser_debug(state, "typedef \"%s\" -> \"%s\"\n", typedef_name, base_type_name);
ParserTypePair *typedef_pair = c_parser_new_typedef(state, typedef_name, base_type_name);
if (!typedef_pair) {
parser_error(state, "Error forming RzType and RzBaseType pair out of typedef: \"%s\"\n", typedef_name);
return -1;
}
// If parsing successfull completed - we store the state
if (typedef_pair) {
typedef_pair->btype->type = rz_type_clone(type_pair->type);
parser_debug(state, "storing typedef \"%s\" -> \"%s\"\n", typedef_name, base_type_name);
c_parser_base_type_store(state, typedef_name, typedef_pair);
// If it was a forward definition previously - remove it
if (c_parser_base_type_is_forward_definition(state, typedef_name)) {
c_parser_forward_definition_remove(state, typedef_name);
}
}
// FIXME: We should return multiple types at once
*tpair = typedef_pair;
typedef_declarator = ts_node_next_named_sibling(typedef_declarator);
} while (!ts_node_is_null(typedef_declarator) && is_type_declarator(ts_node_type(typedef_declarator)));
return 0;
}
// Parses the node that represents just one type
// Despite the name could parse multiple types at once, if the share the type definition
int parse_type_node_single(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, bool is_const) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
// We skip simple nodes (e.g. conditions and braces)
if (!ts_node_is_named(node)) {
return 0;
}
const char *node_type = ts_node_type(node);
int result = -1;
parser_debug(state, "parse_type_node_single(\"%s\")\n", node_type);
if (!strcmp(node_type, "struct_specifier")) {
result = parse_struct_node(state, node, text, tpair, is_const);
if (result || !*tpair) {
return -1;
}
} else if (!strcmp(node_type, "union_specifier")) {
result = parse_union_node(state, node, text, tpair, is_const);
if (result || !*tpair) {
return -1;
}
} else if (!strcmp(node_type, "enum_specifier")) {
result = parse_enum_node(state, node, text, tpair, is_const);
if (result || !*tpair) {
return -1;
}
} else if (!strcmp(node_type, "type_definition")) {
result = parse_typedef_node(state, node, text, tpair);
if (result || !*tpair) {
return -1;
}
} else if (!strcmp(node_type, "sized_type_specifier")) {
result = parse_sized_primitive_type(state, node, text, tpair, is_const);
if (result || !*tpair) {
return -1;
}
} else if (!strcmp(node_type, "primitive_type")) {
result = parse_primitive_type(state, node, text, tpair, is_const);
if (result || !*tpair) {
return -1;
}
} else if (!strcmp(node_type, "type_identifier")) {
result = parse_sole_type_name(state, node, text, tpair, is_const);
if (result || !*tpair) {
return -1;
}
}
// Another case where there is a declaration clause
// In this case we should drop the declaration itself
// and parse only the corresponding type
// In case of anonymous type we could use identifier as a name for this type?
//
return result;
}
// Parses the parameter list, e.g. in the function types/definition like arguments list
int parse_parameter_list(CParserState *state, TSNode paramlist, const char *text, ParserTypePair **tpair) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(paramlist), -1);
// We skip simple nodes (e.g. conditions and braces)
if (!ts_node_is_named(paramlist)) {
return 0;
}
if ((*tpair)->type->kind != RZ_TYPE_KIND_CALLABLE) {
parser_error(state, "ERROR: Parameter description only acceptable as part of function definition!\n");
return -1;
}
parser_debug(state, "parse_parameter_list()\n");
const char *node_type = ts_node_type(paramlist);
if (strcmp(node_type, "parameter_list")) {
node_malformed_error(state, paramlist, text, "parameter_list");
return -1;
}
int paramlist_child_count = ts_node_named_child_count(paramlist);
if (paramlist_child_count < 1) {
node_malformed_error(state, paramlist, text, "parameter_list");
return -1;
}
int i;
for (i = 0; i < paramlist_child_count; i++) {
parser_debug(state, "parameter_list: processing %d field...\n", i);
TSNode child = ts_node_named_child(paramlist, i);
const char *node_type = ts_node_type(child);
// Every field should have (parameter_declaration) AST clause
if (strcmp(node_type, "parameter_declaration") && strcmp(node_type, "variadic_parameter")) {
parser_error(state, "ERROR: Parameter field AST should contain (parameter_declaration|variadic_parameter) node!\n");
node_malformed_error(state, child, text, "parameter_declaration|variadic_parameter");
return -1;
}
if (!strcmp(node_type, "variadic_parameter")) {
// This is a variadic parameter "...", let's ignore it for now
parser_debug(state, "Processing variadic parameter, ignoring for now...\n", i);
continue;
}
char *identifier = NULL;
// Create new TypePair here
ParserTypePair *argtpair = NULL;
if (parse_parameter_declaration_node(state, child, text, &argtpair, &identifier)) {
parser_error(state, "ERROR: Parsing parameter declarator!\n");
return -1;
}
if (!argtpair || !argtpair->type) {
free(argtpair);
return -1;
}
// Store the parameters if available
// If the name is not available just name it as "argN" where N is argument index
if (!identifier) {
identifier = rz_str_newf("arg%d", i);
}
parser_debug(state, "Adding \"%s\" parameter\n", identifier);
RzType *argtp = argtpair->type;
free(argtpair);
if (!c_parser_new_callable_argument(state, (*tpair)->type->callable, identifier, argtp)) {
parser_error(state, "ERROR: Cannot add the parameter to the function!\n");
free(identifier);
return -1;
}
free(identifier);
}
return 0;
}
// Parses abstract declarator node - i.e. the type without the identifier
int parse_type_abstract_declarator_node(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
rz_return_val_if_fail(ts_node_is_named(node), -1);
parser_debug(state, "parse_type_abstract_declarator_node()\n");
// Parse the type qualifier first (if present)
// FIXME: There could be multiple different type qualifiers in one declaration
bool is_const = false;
bool has_qualifiers = false;
int node_child_count = ts_node_named_child_count(node);
if (node_child_count > 0) {
TSNode first_leaf = ts_node_named_child(node, 0);
if (ts_node_is_null(first_leaf)) {
node_malformed_error(state, node, text, "type_declarator_node");
return -1;
}
const char *leaf_type = ts_node_type(first_leaf);
// If we have type qualifier in this position it is related to
// the declarator itself, not the type, e.g. constant pointer,
// not pointer to the constant
if (!strcmp(leaf_type, "type_qualifier")) {
char *qualifier = ts_node_sub_string(first_leaf, text);
parser_debug(state, "has qualifier %s\n", qualifier);
if (!strcmp(qualifier, "const")) {
is_const = true;
}
has_qualifiers = true;
free(qualifier);
}
}
const char *node_type = ts_node_type(node);
int result = -1;
if (!strcmp(node_type, "abstract_pointer_declarator")) {
parser_debug(state, "abstract pointer declarator\n");
// Now we wrap the existing type into the new one
// The base type in the type pair remains the same
RzType *type = RZ_NEW0(RzType);
if (!type) {
return -1;
}
type->kind = RZ_TYPE_KIND_POINTER;
type->pointer.is_const = is_const;
type->pointer.type = (*tpair)->type;
(*tpair)->type = type;
// It can contain additional children as:
// - "abstract_array_declarator"
// - "abstract_pointer_declarator"
// - "abstract_function_declarator"
// - Or multiple "type qualifiers"
int pointer_node_child_count = ts_node_named_child_count(node);
if (pointer_node_child_count > 0) {
TSNode pointer_declarator = ts_node_child_by_field_name(node, "declarator", 10);
if (ts_node_is_null(pointer_declarator) && !has_qualifiers) {
parser_error(state, "ERROR: Abstract pointer declarator AST should contain at least one node!\n");
node_malformed_error(state, node, text, "pointer declarator");
free(type);
(*tpair)->type = NULL;
return -1;
}
if (!ts_node_is_null(pointer_declarator)) {
const char *declarator_type = ts_node_type(pointer_declarator);
if (!declarator_type) {
node_malformed_error(state, pointer_declarator, text, "pointer declarator");
free(type);
(*tpair)->type = NULL;
return -1;
}
if (is_abstract_declarator(declarator_type)) {
result = parse_type_abstract_declarator_node(state, pointer_declarator, text, tpair);
} else {
result = 0;
}
} else {
result = 0;
}
} else {
parser_debug(state, "abstract pointer declarator has no children\n");
result = 0;
}
} else if (!strcmp(node_type, "abstract_array_declarator")) {
// It can have two states - with and without number literal
int array_node_child_count = ts_node_named_child_count(node);
if (array_node_child_count < 0 || array_node_child_count > 2) {
node_malformed_error(state, node, text, "abstract_array_declarator");
return -1;
}
// Now we wrap the existing type into the new one
// The base type in the type pair remains the same
RzType *type = RZ_NEW0(RzType);
if (!type) {
return -1;
}
type->kind = RZ_TYPE_KIND_ARRAY;
// Optional number_literal node
TSNode array_size = ts_node_child_by_field_name(node, "size", 4);
if (ts_node_is_null(array_size)) {
type->array.count = 0;
} else {
char *real_array_size = ts_node_sub_string(array_size, text);
if (!real_array_size) {
node_malformed_error(state, array_size, text, "abstract array size");
free(type);
return -1;
}
int array_sz = rz_num_get(NULL, real_array_size);
type->array.count = array_sz;
free(real_array_size);
}
type->array.type = (*tpair)->type;
(*tpair)->type = type;
// It also can contain the following abstract declarators as a child:
// - abstract_array_declarator
// - abstract_pointer_declarator
TSNode array_declarator = ts_node_child_by_field_name(node, "declarator", 10);
if (!ts_node_is_null(array_declarator)) {
const char *declarator_type = ts_node_type(array_declarator);
if (!declarator_type) {
node_malformed_error(state, array_declarator, text, "declarator");
return -1;
}
if (is_abstract_declarator(declarator_type)) {
result = parse_type_abstract_declarator_node(state, array_declarator, text, tpair);
} else {
result = 0;
}
} else {
result = 0;
}
} else if (!strcmp(node_type, "abstract_function_declarator")) {
// It can only contain two nodes:
// - abstract_parenthesized_declarator (usually empty)
// - parameter_list
int function_node_child_count = ts_node_named_child_count(node);
if (function_node_child_count != 1) {
node_malformed_error(state, node, text, "abstract_function_declarator");
return -1;
}
TSNode parenthesized_declarator = ts_node_child_by_field_name(node, "declarator", 10);
if (ts_node_is_null(parenthesized_declarator) || !ts_node_is_named(parenthesized_declarator)) {
node_malformed_error(state, parenthesized_declarator, text, "parenthesized_declarator");
return -1;
}
const char *declarator_type = ts_node_type(parenthesized_declarator);
if (strcmp(declarator_type, "parenthesized_declarator")) {
node_malformed_error(state, parenthesized_declarator, text, "parenthesized_declarator");
return -1;
}
// Parsing parameters list
TSNode parameter_list = ts_node_child_by_field_name(node, "parameters", 10);
if (ts_node_is_null(parameter_list) || !ts_node_is_named(parameter_list)) {
node_malformed_error(state, parameter_list, text, "parameter_list");
return -1;
}
const char *param_list_type = ts_node_type(parameter_list);
if (strcmp(param_list_type, "parameter_list")) {
node_malformed_error(state, parameter_list, text, "parameter_list");
return -1;
}
// Generate a sequential function type name if it's not specified
const char *name = c_parser_new_anonymous_callable_name(state);
RzType *parent_type = (*tpair)->type;
(*tpair)->type = c_parser_new_callable(state, name);
if (!(*tpair)->type) {
parser_error(state, "ERROR: creating new callable type: \"%s\"\n", name);
return -1;
}
result = parse_parameter_list(state, parameter_list, text, tpair);
if (result) {
parser_error(state, "ERROR: parsing parameters for callable type: \"%s\"\n", name);
return -1;
}
// The previously fetched type in this case is the callable return type
(*tpair)->type->callable->ret = parent_type;
if (!c_parser_callable_type_store(state, name, (*tpair)->type)) {
parser_error(state, "ERROR: storing the new callable type: \"%s\"\n", name);
return -1;
}
}
return result;
}
static bool is_identifier(const char *type) {
return (!strcmp(type, "identifier") || !strcmp(type, "field_identifier") || !strcmp(type, "type_identifier"));
}
// Parses the concrete type declarator - i.e. type with the identifier
// It doesn't allocate a new ParserTypePair, but augments already existing one
// Also it returns the identifier name
int parse_type_declarator_node(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair, char **identifier) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
rz_return_val_if_fail(ts_node_is_named(node), -1);
parser_debug(state, "parse_type_declarator_node()\n");
// Parse the type qualifier first
// FIXME: There could be multiple different type qualifiers in one declaration
bool is_const = false;
int node_child_count = ts_node_named_child_count(node);
if (node_child_count > 0) {
TSNode first_leaf = ts_node_named_child(node, 0);
if (ts_node_is_null(first_leaf)) {
node_malformed_error(state, node, text, "type_declarator_node");
return -1;
}
const char *leaf_type = ts_node_type(first_leaf);
if (!strcmp(leaf_type, "type_qualifier")) {
char *qualifier = ts_node_sub_string(first_leaf, text);
parser_debug(state, "has qualifier %s\n", qualifier);
if (!strcmp(qualifier, "const")) {
is_const = true;
}
free(qualifier);
}
}
const char *node_type = ts_node_type(node);
int result = -1;
if (is_identifier(node_type)) {
// Identifier, usually the last leaf of the AST tree
char *real_ident = ts_node_sub_string(node, text);
parser_debug(state, "identifier: %s\n", real_ident);
*identifier = real_ident;
result = 0;
} else if (!strcmp(node_type, "pointer_declarator")) {
char *real_ident = ts_node_sub_string(node, text);
parser_debug(state, "pointer declarator: %s\n", real_ident);
// It can contain additional children recursively
// - "array_declarator"
// - "pointer_declarator"
// - "function_declarator"
// - "identifier"
// Every pointer declarator should have at least declarator field
TSNode pointer_declarator = ts_node_child_by_field_name(node, "declarator", 10);
if (ts_node_is_null(pointer_declarator)) {
parser_error(state, "ERROR: Pointer declarator AST should contain at least one node!\n");
node_malformed_error(state, node, text, "pointer declarator");
free(real_ident);
return -1;
}
const char *declarator_type = ts_node_type(pointer_declarator);
if (!declarator_type) {
node_malformed_error(state, pointer_declarator, text, "pointer declarator");
free(real_ident);
return -1;
}
// Now we wrap the existing type into the new one
// The base type in the type pair remains the same
RzType *type = RZ_NEW0(RzType);
if (!type) {
free(real_ident);
return -1;
}
type->kind = RZ_TYPE_KIND_POINTER;
type->pointer.is_const = is_const;
type->pointer.type = (*tpair)->type;
(*tpair)->type = type;
if (is_declarator(declarator_type) || is_identifier(declarator_type)) {
result = parse_type_declarator_node(state, pointer_declarator, text, tpair, identifier);
} else {
result = 0;
}
free(real_ident);
} else if (!strcmp(node_type, "array_declarator")) {
char *real_ident = ts_node_sub_string(node, text);
parser_debug(state, "array declarator: %s\n", real_ident);
free(real_ident);
// Every array declarator should have at least declarator field
// The size field is optional
TSNode array_declarator = ts_node_child_by_field_name(node, "declarator", 10);
TSNode array_size = ts_node_child_by_field_name(node, "size", 4);
if (ts_node_is_null(array_declarator)) {
parser_error(state, "ERROR: Array declarator AST should contain at least one node!\n");
node_malformed_error(state, node, text, "array declarator");
return -1;
}
const char *declarator_type = ts_node_type(array_declarator);
if (!declarator_type) {
node_malformed_error(state, array_declarator, text, "array declarator");
return -1;
}
// Now we wrap the existing type into the new one
// The base type in the type pair remains the same
RzType *type = RZ_NEW0(RzType);
if (!type) {
return -1;
}
type->kind = RZ_TYPE_KIND_ARRAY;
if (ts_node_is_null(array_size)) {
type->array.count = 0;
} else {
// number_literal node
char *real_array_size = ts_node_sub_string(array_size, text);
if (!real_array_size) {
node_malformed_error(state, array_size, text, "array size");
free(type);
return -1;
}
int array_sz = rz_num_get(NULL, real_array_size);
type->array.count = array_sz;
free(real_array_size);
}
type->array.type = (*tpair)->type;
(*tpair)->type = type;
parser_debug(state, "array declarator type: %s\n", declarator_type);
if (is_declarator(declarator_type) || is_identifier(declarator_type)) {
result = parse_type_declarator_node(state, array_declarator, text, tpair, identifier);
} else {
return 0;
}
} else if (!strcmp(node_type, "function_declarator")) {
char *real_ident = ts_node_sub_string(node, text);
parser_debug(state, "function declarator: %s\n", real_ident);
free(real_ident);
// It can only contain two nodes:
// - declarator
// - parameters
int function_node_child_count = ts_node_named_child_count(node);
if (function_node_child_count > 2) {
node_malformed_error(state, node, text, "function_declarator");
return -1;
}
TSNode declarator = ts_node_child_by_field_name(node, "declarator", 10);
if (ts_node_is_null(declarator) || !ts_node_is_named(declarator)) {
node_malformed_error(state, declarator, text, "declarator");
return -1;
}
const char *declarator_type = ts_node_type(declarator);
// Declarator could be either parenthesized_declarator or identifier
if (!is_function_declarator(declarator_type)) {
node_malformed_error(state, declarator, text, "function declarator or identifier");
return -1;
}
RzType *parent_type = (*tpair)->type;
// At first we create "freestanding" unnamed callable
RzType *naked_callable = c_parser_new_naked_callable(state);
if (!naked_callable) {
parser_error(state, "ERROR: creating naked callable type\n");
return -1;
}
// The previously fetched type in this case is the callable return type
naked_callable->callable->ret = parent_type;
(*tpair)->type = naked_callable;
// Declarator can be either "identifier" directly or have children
if (is_identifier(declarator_type)) {
parser_debug(state, "function declarator: simple identifier\n");
if (parse_type_declarator_node(state, declarator, text, tpair, identifier)) {
parser_error(state, "ERROR: parsing function declarator\n");
node_malformed_error(state, declarator, text, "function identifier");
return -1;
}
} else {
TSNode function_declarator = ts_node_named_child(declarator, 0);
const char *function_declarator_type = ts_node_type(function_declarator);
if (!function_declarator_type) {
node_malformed_error(state, function_declarator, text, "function declarator");
return -1;
}
// Declarator can contain either "identifier" directly
// Or the pointer_declarator instead (or multiple of them nested in each other)
if (is_declarator(function_declarator_type) || is_identifier(function_declarator_type)) {
if (parse_type_declarator_node(state, function_declarator, text, tpair, identifier)) {
parser_error(state, "ERROR: parsing function declarator\n");
node_malformed_error(state, function_declarator, text, "function declarator");
return -1;
}
} else {
parser_error(state, "ERROR: missing function declarator\n");
node_malformed_error(state, function_declarator, text, "function declarator");
return -1;
}
}
// Parsing parameters list
TSNode parameter_list = ts_node_child_by_field_name(node, "parameters", 10);
if (ts_node_is_null(parameter_list) || !ts_node_is_named(parameter_list)) {
node_malformed_error(state, parameter_list, text, "parameter_list");
return -1;
}
const char *param_list_type = ts_node_type(parameter_list);
if (strcmp(param_list_type, "parameter_list")) {
node_malformed_error(state, parameter_list, text, "parameter_list");
return -1;
}
naked_callable->callable->name = strdup(*identifier);
// Preserve the parent callable type
parent_type = (*tpair)->type;
// Then override with the naked callable type to proceed with parameter parsing
(*tpair)->type = naked_callable;
result = parse_parameter_list(state, parameter_list, text, tpair);
if (result) {
parser_error(state, "ERROR: parsing parameters for callable type: \"%s\"\n", *identifier);
return -1;
}
// Restore the true parent type
(*tpair)->type = parent_type;
if (!c_parser_callable_type_store(state, *identifier, naked_callable)) {
parser_error(state, "ERROR: storing the new callable type: \"%s\"\n", *identifier);
return -1;
}
}
return result;
}
// Parses the single type descriptor - it can be either concrete or an abstract one
// In the case of concrete descriptor it calls "parse_type_declarator_node()"
// In the case of abstract descriptor it calls "parse_type_abstract_declarator_node()"
int parse_type_descriptor_single(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
// We skip simple nodes (e.g. conditions and braces)
if (!ts_node_is_named(node)) {
return 0;
}
const char *node_type = ts_node_type(node);
int result = -1;
if (strcmp(node_type, "type_descriptor")) {
return -1;
}
parser_debug(state, "parse_type_descriptor_single()\n");
int typedesc_node_child_count = ts_node_named_child_count(node);
if (typedesc_node_child_count < 1) {
node_malformed_error(state, node, text, "type_descriptor");
return -1;
}
// Type descriptor has three fields:
// 0. type qualifier (optional)
// 1. type itself
// 2. declarator field (optional)
// Parse the type qualifier first
// FIXME: There could be multiple different type qualifiers in one declaration
bool is_const = false;
TSNode first_leaf = ts_node_named_child(node, 0);
if (ts_node_is_null(first_leaf)) {
node_malformed_error(state, node, text, "type_descriptor");
return -1;
}
const char *leaf_type = ts_node_type(first_leaf);
if (!strcmp(leaf_type, "type_qualifier")) {
char *qualifier = ts_node_sub_string(first_leaf, text);
parser_debug(state, "has qualifier \"%s\"\n", qualifier);
if (!strcmp(qualifier, "const")) {
parser_debug(state, "set const\n");
is_const = true;
}
free(qualifier);
}
TSNode type_node = ts_node_child_by_field_name(node, "type", 4);
if (ts_node_is_null(type_node)) {
node_malformed_error(state, node, text, "type_descriptor");
parser_error(state, "type_descriptor's type field cannot be NULL\n");
return -1;
}
if (parse_type_node_single(state, type_node, text, tpair, is_const)) {
node_malformed_error(state, node, text, "type_descriptor");
parser_error(state, "Cannot parse type_descriptor's type field\n");
return -1;
}
if (!*tpair) {
parser_error(state, "Failed to parse type_descriptor's type field\n");
return -1;
}
// 2. Optional declarator field
TSNode type_declarator = ts_node_child_by_field_name(node, "declarator", 10);
if (!ts_node_is_null(type_declarator)) {
return parse_type_abstract_declarator_node(state, type_declarator, text, tpair);
} else {
result = 0;
}
return result;
}
// Parses the declaration node
int parse_declaration_node(CParserState *state, TSNode node, const char *text, ParserTypePair **tpair) {
rz_return_val_if_fail(state && text && tpair, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
// We skip simple nodes (e.g. conditions and braces)
if (!ts_node_is_named(node)) {
return 0;
}
const char *node_type = ts_node_type(node);
int result = -1;
if (strcmp(node_type, "declaration")) {
return -1;
}
parser_debug(state, "parse_type_declaration_node()\n");
int declaration_node_child_count = ts_node_named_child_count(node);
if (declaration_node_child_count < 1) {
node_malformed_error(state, node, text, "declaration");
return -1;
}
// Type declaration has three fields:
// 0. type qualifier (optional)
// 1. type itself
// 2. declarator field (optional)
// Parse the type qualifier first
// FIXME: There could be multiple different type qualifiers in one declaration
bool is_const = false;
TSNode first_leaf = ts_node_named_child(node, 0);
if (ts_node_is_null(first_leaf)) {
node_malformed_error(state, node, text, "declaration");
return -1;
}
const char *leaf_type = ts_node_type(first_leaf);
if (!strcmp(leaf_type, "type_qualifier")) {
char *qualifier = ts_node_sub_string(first_leaf, text);
parser_debug(state, "has qualifier \"%s\"\n", qualifier);
if (!strcmp(qualifier, "const")) {
parser_debug(state, "set const\n");
is_const = true;
}
free(qualifier);
}
TSNode type_node = ts_node_child_by_field_name(node, "type", 4);
if (ts_node_is_null(type_node)) {
node_malformed_error(state, node, text, "declaration");
parser_error(state, "declaration's type field cannot be NULL\n");
return -1;
}
if (parse_type_node_single(state, type_node, text, tpair, is_const)) {
node_malformed_error(state, node, text, "declaration");
parser_error(state, "Cannot parse declaration's type field\n");
return -1;
}
if (!*tpair) {
parser_error(state, "Failed to parse declaration's type field\n");
return -1;
}
// 2. Optional declarator field
TSNode type_declarator = ts_node_child_by_field_name(node, "declarator", 10);
if (!ts_node_is_null(type_declarator)) {
char *identifier = NULL;
return parse_type_declarator_node(state, type_declarator, text, tpair, &identifier);
} else {
result = 0;
}
return result;
}
// Types can be
// - struct (struct_specifier)
// - union (union_specifier)
// - enum (enum_specifier) (usually prepended by declaration)
// - typedef (type_definition)
// - atomic type (primitive_type)
// - declaration ()
// Parses the node and saves the resulting RzBaseTypes in the state hashtables
int parse_type_nodes_save(CParserState *state, TSNode node, const char *text) {
rz_return_val_if_fail(state && text, -1);
rz_return_val_if_fail(!ts_node_is_null(node), -1);
// We skip simple nodes (e.g. conditions and braces)
if (!ts_node_is_named(node)) {
return 0;
}
const char *node_type = ts_node_type(node);
int result = -1;
ParserTypePair *tpair = NULL;
if (!strcmp(node_type, "struct_specifier")) {
result = parse_struct_node(state, node, text, &tpair, false);
if (result || !tpair) {
return -1;
}
} else if (!strcmp(node_type, "union_specifier")) {
result = parse_union_node(state, node, text, &tpair, false);
if (result || !tpair) {
return -1;
}
} else if (!strcmp(node_type, "enum_specifier")) {
result = parse_enum_node(state, node, text, &tpair, false);
if (result || !tpair) {
return -1;
}
} else if (!strcmp(node_type, "type_definition")) {
result = parse_typedef_node(state, node, text, &tpair);
if (result || !tpair) {
return -1;
}
}
// Another case where there is a declaration clause
// In this case we should drop the declaration itself
// and parse only the corresponding type. An exception for this
// rule is the function declaration.
if (!strcmp(node_type, "declaration")) {
result = parse_declaration_node(state, node, text, &tpair);
if (result || !tpair) {
return -1;
}
}
if (tpair) {
rz_type_free(tpair->type);
free(tpair);
}
if (result) {
char *typetext = ts_node_sub_string(node, text);
parser_error(state, "Unsupported type definition: %s\n", typetext);
free(typetext);
}
// In case of anonymous type we could use identifier as a name for this type?
return result;
}
rizin-0.7.4/librz/type/parser/types_storage.c 0000664 0001750 0001750 00000063526 14731035230 020664 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#include
#include
#include
// Searching and storing types in the context of the parser (types and callables hashables)
// Base types
RzBaseType *c_parser_base_type_find(CParserState *state, RZ_NONNULL const char *name) {
bool found = false;
RzBaseType *base_type = ht_pp_find(state->types, name, &found);
if (!found || !base_type) {
return NULL;
}
return base_type;
}
bool c_parser_base_type_is_forward_definition(CParserState *state, RZ_NONNULL const char *name) {
bool found = false;
ht_pp_find(state->forward, name, &found);
return found;
}
bool c_parser_base_type_exists(CParserState *state, RZ_NONNULL const char *name) {
return c_parser_base_type_find(state, name) != NULL;
}
bool c_parser_base_type_store(CParserState *state, RZ_NONNULL const char *name, ParserTypePair *tpair) {
rz_return_val_if_fail(state && name && tpair && tpair->btype, -1);
if (c_parser_base_type_exists(state, name)) {
// We don't create the type if it exists already in the parser
// state with the same name
return false;
}
// We store only RzBaseType part of the type pair
ht_pp_insert(state->types, name, tpair->btype);
return true;
}
bool c_parser_forward_definition_store(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, -1);
if (c_parser_base_type_exists(state, name)) {
// We don't create the forward definition if it exists already in the parser
// types table state with the same name
return false;
}
if (c_parser_base_type_is_forward_definition(state, name)) {
// We don't create the forward definition if it already stored
// as the forward definition with the same name
return false;
}
// We store only the type name
ht_pp_insert(state->forward, name, NULL);
return true;
}
bool c_parser_forward_definition_remove(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, -1);
if (c_parser_base_type_exists(state, name)) {
// We don't create the forward definition if it exists already in the parser
// types table state with the same name
return false;
}
ht_pp_delete(state->forward, name);
return true;
}
// Callable types
RzCallable *c_parser_callable_type_find(CParserState *state, RZ_NONNULL const char *name) {
bool found = false;
RzCallable *callable = ht_pp_find(state->callables, name, &found);
if (!found || !callable) {
return NULL;
}
return callable;
}
bool c_parser_callable_type_exists(CParserState *state, RZ_NONNULL const char *name) {
return c_parser_callable_type_find(state, name) != NULL;
}
bool c_parser_callable_type_store(CParserState *state, RZ_NONNULL const char *name, RZ_NONNULL RzType *type) {
rz_return_val_if_fail(state && name && type, -1);
rz_return_val_if_fail(type->kind == RZ_TYPE_KIND_CALLABLE, -1);
rz_return_val_if_fail(type->callable, -1);
if (c_parser_callable_type_exists(state, name)) {
// We don't create the type if it exists already in the parser
// state with the same name
return false;
}
ht_pp_insert(state->callables, name, type->callable);
parser_debug(state, "Stored \"%s\" callable type\n", name);
return true;
}
/**
* \brief Creates new unspecified naked type (without base type) based on the name
*
* \param state The parser state
* \param name Name of the type to create
* \param is_const If the identifier is constant
*/
RZ_OWN ParserTypePair *c_parser_new_unspecified_naked_type(CParserState *state, RZ_NONNULL const char *name, bool is_const) {
rz_return_val_if_fail(state && name, NULL);
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
type->kind = RZ_TYPE_KIND_IDENTIFIER;
type->identifier.is_const = is_const;
type->identifier.name = strdup(name);
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
if (!tpair) {
rz_type_free(type);
return NULL;
}
tpair->btype = NULL;
tpair->type = type;
return tpair;
}
/**
* \brief Creates new primitive type based on the name
*
* \param state The parser state
* \param name Name of the primitive C type to create
* \param is_const If the primitive type is const
*/
RZ_OWN ParserTypePair *c_parser_new_primitive_type(CParserState *state, RZ_NONNULL const char *name, bool is_const) {
rz_return_val_if_fail(state && name, NULL);
if (c_parser_base_type_exists(state, name)) {
// We don't create the type if it exists already in the parser
// state with the same name
parser_error(state, "Primitive type \"%s\" already exists\n", name);
return NULL;
}
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
type->kind = RZ_TYPE_KIND_IDENTIFIER;
type->identifier.is_const = is_const;
type->identifier.name = strdup(name);
if (!type->identifier.name) {
free(type);
return NULL;
}
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_ATOMIC);
if (!base_type) {
rz_type_free(type);
return NULL;
}
base_type->name = strdup(name);
if (!base_type->name) {
rz_type_free(type);
rz_type_base_type_free(base_type);
return NULL;
}
ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
if (!tpair) {
rz_type_free(type);
rz_type_base_type_free(base_type);
return NULL;
}
tpair->btype = base_type;
tpair->type = type;
return tpair;
}
/**
* \brief Returns the primitive type if matching in the types hashtable
*
* If the name matches with the name of one of the base types
* that are in the hashtable of the existing types in the parser
* state, then it creates new RzType with the found RzBaseType as a base.
* Then it wraps boths in the "type pair"
*
* \param state The parser state
* \param name Name of the primitive type to fetch
* \param is_const If the primitive type is const
*/
RZ_OWN ParserTypePair *c_parser_get_primitive_type(CParserState *state, RZ_NONNULL const char *name, bool is_const) {
rz_return_val_if_fail(state && name, NULL);
RzBaseType *base_type = c_parser_base_type_find(state, name);
if (!base_type || base_type->kind != RZ_BASE_TYPE_KIND_ATOMIC) {
return NULL;
}
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
type->kind = RZ_TYPE_KIND_IDENTIFIER;
type->identifier.is_const = is_const;
type->identifier.name = strdup(name);
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
if (!tpair) {
rz_type_free(type);
return NULL;
}
tpair->btype = base_type;
tpair->type = type;
return tpair;
}
/**
* \brief Creates new structure naked type (without base type) based on the name
*
* \param state The parser state
* \param name Name of the structure C type to create
*/
RZ_OWN ParserTypePair *c_parser_new_structure_naked_type(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
type->kind = RZ_TYPE_KIND_IDENTIFIER;
type->identifier.is_const = false;
type->identifier.name = strdup(name);
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_STRUCT;
ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
if (!tpair) {
rz_type_free(type);
return NULL;
}
tpair->btype = NULL;
tpair->type = type;
return tpair;
}
/**
* \brief Creates new structure "type + base type" pair based on the name
*
* \param state The parser state
* \param name Name of the structure C type to create
* \param members_count The count of the structure members
*/
RZ_OWN ParserTypePair *c_parser_new_structure_type(CParserState *state, RZ_NONNULL const char *name, size_t members_count) {
rz_return_val_if_fail(state && name, NULL);
if (c_parser_base_type_exists(state, name)) {
// We don't create the structure if it exists already in the parser
// state with the same name
parser_error(state, "Structure type \"%s\" already exists\n", name);
return NULL;
}
ParserTypePair *tpair = c_parser_new_structure_naked_type(state, name);
if (!tpair) {
return NULL;
}
RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_STRUCT);
if (!base_type) {
rz_type_free(tpair->type);
free(tpair);
return NULL;
}
base_type->name = strdup(name);
base_type->type = NULL;
tpair->btype = base_type;
RzVector *members = &base_type->struct_data.members;
if (members_count > 0 && !rz_vector_reserve(members, members_count)) {
rz_type_free(tpair->type);
rz_type_base_type_free(tpair->btype);
free(tpair);
return NULL;
}
return tpair;
}
/**
* \brief Returns the structure type if matching in the types hashtable
*
* If the name matches with the name of one of the base types
* that are in the hashtable of the existing types in the parser
* state, then it creates new RzType with the found RzBaseType as a base.
* Then it wraps boths in the "type pair"
*
* \param state The parser state
* \param name Name of the structure type to fetch
*/
RZ_OWN ParserTypePair *c_parser_get_structure_type(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
RzBaseType *base_type = c_parser_base_type_find(state, name);
if (!base_type || base_type->kind != RZ_BASE_TYPE_KIND_STRUCT) {
return NULL;
}
ParserTypePair *tpair = c_parser_new_structure_naked_type(state, name);
if (!tpair) {
return NULL;
}
tpair->btype = base_type;
return tpair;
}
/**
* \brief Creates new structure forward definition
*
* \param state The parser state
* \param name Name of the structure C type to create
*/
RZ_OWN ParserTypePair *c_parser_new_structure_forward_definition(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
if (c_parser_base_type_exists(state, name)) {
// We don't create the structure if it exists already in the parser
// state with the same name
return NULL;
}
if (c_parser_base_type_is_forward_definition(state, name)) {
// We don't create the structure if it exists already in the forward
// definitions table with the same name
return NULL;
}
ParserTypePair *tpair = c_parser_new_structure_naked_type(state, name);
if (!tpair) {
return NULL;
}
return tpair;
}
/**
* \brief Creates new union naked type (without base type) based on the name
*
* \param state The parser state
* \param name Name of the union C type to create
*/
RZ_OWN ParserTypePair *c_parser_new_union_naked_type(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
type->kind = RZ_TYPE_KIND_IDENTIFIER;
type->identifier.is_const = false;
type->identifier.name = strdup(name);
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNION;
ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
if (!tpair) {
rz_type_free(type);
return NULL;
}
tpair->btype = NULL;
tpair->type = type;
return tpair;
}
/**
* \brief Creates new union "type + base type" pair based on the name
*
* \param state The parser state
* \param name Name of the union C type to create
* \param members_count The count of the union members
*/
RZ_OWN ParserTypePair *c_parser_new_union_type(CParserState *state, RZ_NONNULL const char *name, size_t members_count) {
rz_return_val_if_fail(state && name, NULL);
if (c_parser_base_type_exists(state, name)) {
// We don't create the structure if it exists already in the parser
// state with the same name
parser_error(state, "Union type \"%s\" already exists\n", name);
return NULL;
}
ParserTypePair *tpair = c_parser_new_union_naked_type(state, name);
if (!tpair) {
return NULL;
}
RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_UNION);
if (!base_type) {
rz_type_free(tpair->type);
free(tpair);
return NULL;
}
base_type->name = strdup(name);
base_type->type = NULL;
tpair->btype = base_type;
RzVector *members = &base_type->union_data.members;
if (members_count > 0 && !rz_vector_reserve(members, members_count)) {
rz_type_free(tpair->type);
rz_type_base_type_free(tpair->btype);
free(tpair);
return NULL;
}
return tpair;
}
/**
* \brief Returns the union type if matching in the types hashtable
*
* If the name matches with the name of one of the base types
* that are in the hashtable of the existing types in the parser
* state, then it creates new RzType with the found RzBaseType as a base.
* Then it wraps boths in the "type pair"
*
* \param state The parser state
* \param name Name of the union type to fetch
*/
RZ_OWN ParserTypePair *c_parser_get_union_type(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
RzBaseType *base_type = c_parser_base_type_find(state, name);
if (!base_type || base_type->kind != RZ_BASE_TYPE_KIND_UNION) {
return NULL;
}
ParserTypePair *tpair = c_parser_new_union_naked_type(state, name);
if (!tpair) {
return NULL;
}
tpair->btype = base_type;
return tpair;
}
/**
* \brief Creates new union forward definition
*
* \param state The parser state
* \param name Name of the union C type to create
*/
RZ_OWN ParserTypePair *c_parser_new_union_forward_definition(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
if (c_parser_base_type_exists(state, name)) {
// We don't create the union if it exists already in the parser
// state with the same name
return NULL;
}
if (c_parser_base_type_is_forward_definition(state, name)) {
// We don't create the union if it exists already in the forward
// definitions table with the same name
return NULL;
}
ParserTypePair *tpair = c_parser_new_union_naked_type(state, name);
if (!tpair) {
return NULL;
}
return tpair;
}
/**
* \brief Creates new enum naked type (without base type) based on the name
*
* \param state The parser state
* \param name Name of the enum C type to create
*/
RZ_OWN ParserTypePair *c_parser_new_enum_naked_type(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
type->kind = RZ_TYPE_KIND_IDENTIFIER;
type->identifier.is_const = false;
type->identifier.name = strdup(name);
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_ENUM;
ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
if (!tpair) {
rz_type_free(type);
return NULL;
}
tpair->btype = NULL;
tpair->type = type;
return tpair;
}
/**
* \brief Creates new enumeration type based on the name
*
* \param state The parser state
* \param name Name of the primitive C type to create
* \param cases_count The count of the enum cases
*/
RZ_OWN ParserTypePair *c_parser_new_enum_type(CParserState *state, RZ_NONNULL const char *name, size_t cases_count) {
rz_return_val_if_fail(state && name, NULL);
if (c_parser_base_type_exists(state, name)) {
// We don't create the structure if it exists already in the parser
// state with the same name
parser_error(state, "Enum type \"%s\" already exists\n", name);
return NULL;
}
ParserTypePair *tpair = c_parser_new_enum_naked_type(state, name);
if (!tpair) {
return NULL;
}
RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_ENUM);
if (!base_type) {
rz_type_free(tpair->type);
free(tpair);
return NULL;
}
base_type->name = strdup(name);
base_type->type = NULL;
tpair->btype = base_type;
RzVector *cases = &base_type->enum_data.cases;
if (cases_count > 0 && !rz_vector_reserve(cases, cases_count)) {
rz_type_free(tpair->type);
rz_type_base_type_free(tpair->btype);
free(tpair);
return NULL;
}
return tpair;
}
/**
* \brief Returns the enum type if matching in the types hashtable
*
* If the name matches with the name of one of the base types
* that are in the hashtable of the existing types in the parser
* state, then it creates new RzType with the found RzBaseType as a base.
* Then it wraps boths in the "type pair"
*
* \param state The parser state
* \param name Name of the enum type to fetch
*/
RZ_OWN ParserTypePair *c_parser_get_enum_type(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
RzBaseType *base_type = c_parser_base_type_find(state, name);
if (!base_type || base_type->kind != RZ_BASE_TYPE_KIND_ENUM) {
return NULL;
}
ParserTypePair *tpair = c_parser_new_enum_naked_type(state, name);
if (!tpair) {
return NULL;
}
tpair->btype = base_type;
return tpair;
}
/**
* \brief Creates new enum forward definition
*
* \param state The parser state
* \param name Name of the enum C type to create
*/
RZ_OWN ParserTypePair *c_parser_new_enum_forward_definition(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
if (c_parser_base_type_exists(state, name)) {
// We don't create the enum if it exists already in the parser
// state with the same name
return NULL;
}
if (c_parser_base_type_is_forward_definition(state, name)) {
// We don't create the enum if it exists already in the forward
// definitions table with the same name
return NULL;
}
ParserTypePair *tpair = c_parser_new_enum_naked_type(state, name);
if (!tpair) {
return NULL;
}
return tpair;
}
/**
* \brief Creates new type alias naked type (without base type) based on the name
*
* \param state The parser state
* \param name Name of the typedef C type to create
*/
RZ_OWN ParserTypePair *c_parser_new_typedef_naked_type(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
type->kind = RZ_TYPE_KIND_IDENTIFIER;
type->identifier.is_const = false;
type->identifier.name = strdup(name);
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
if (!tpair) {
rz_type_free(type);
return NULL;
}
tpair->btype = NULL;
tpair->type = type;
return tpair;
}
/**
* \brief Creates new type alias forward definition
*
* \param state The parser state
* \param name Name of the typedef C type to create
*/
RZ_OWN ParserTypePair *c_parser_new_typedef_forward_definition(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
if (c_parser_base_type_exists(state, name)) {
// We don't create the typedef if it exists already in the parser
// state with the same name
return NULL;
}
if (c_parser_base_type_is_forward_definition(state, name)) {
// We don't create the typedef if it exists already in the forward
// definitions table with the same name
return NULL;
}
ParserTypePair *tpair = c_parser_new_typedef_naked_type(state, name);
if (!tpair) {
return NULL;
}
return tpair;
}
/**
* \brief Creates new type alias based on the name
*
* \param state The parser state
* \param name Name of the primitive C type to create
* \param cases_count The count of the enum cases
*/
RZ_OWN ParserTypePair *c_parser_new_typedef(CParserState *state, RZ_NONNULL const char *name, RZ_NONNULL const char *base) {
rz_return_val_if_fail(state && name, NULL);
if (c_parser_base_type_exists(state, name)) {
// We don't create the type alias if it exists already in the parser
// state with the same name
parser_error(state, "Typedef \"%s\" already exists\n", name);
return NULL;
}
ParserTypePair *tpair = c_parser_new_typedef_naked_type(state, name);
if (!tpair) {
return NULL;
}
RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_TYPEDEF);
if (!base_type) {
rz_type_free(tpair->type);
free(tpair);
return NULL;
}
base_type->name = strdup(name);
if (!c_parser_base_type_exists(state, base)) {
// If it not exists already in the parser
// we create a forward type
base_type->type = NULL;
c_parser_forward_definition_store(state, base);
} else {
RzType *type = RZ_NEW0(RzType);
if (!type) {
rz_type_base_type_free(base_type);
free(tpair);
return NULL;
}
type->kind = RZ_TYPE_KIND_IDENTIFIER;
type->identifier.name = strdup(base);
type->identifier.is_const = false;
base_type->type = type;
}
tpair->btype = base_type;
return tpair;
}
/**
* \brief Returns the type if matching in the types hashtable
*
* If the name matches with the name of one of the type aliases
* that are in the hashtable of the existing types in the parser
* state, then it creates new RzType with the found RzBaseType as a base.
* Then it wraps boths in the "type pair"
*
* \param state The parser state
* \param name Name of the type alias to fetch
*/
RZ_OWN ParserTypePair *c_parser_get_typedef(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
RzBaseType *base_type = c_parser_base_type_find(state, name);
if (!base_type || base_type->kind != RZ_BASE_TYPE_KIND_TYPEDEF) {
return NULL;
}
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
type->kind = RZ_TYPE_KIND_IDENTIFIER;
type->identifier.is_const = false;
type->identifier.name = strdup(name);
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
ParserTypePair *tpair = RZ_NEW0(ParserTypePair);
if (!tpair) {
rz_type_free(type);
return NULL;
}
tpair->btype = base_type;
tpair->type = type;
return tpair;
}
/**
* \brief Creates new naked callable without storing it
*
* \param state The parser state
*/
RZ_OWN RzType *c_parser_new_naked_callable(CParserState *state) {
rz_return_val_if_fail(state, NULL);
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
RzCallable *callable = RZ_NEW0(RzCallable);
if (!callable) {
free(type);
return NULL;
}
callable->name = NULL;
callable->args = rz_pvector_new((RzPVectorFree)rz_type_callable_arg_free);
type->kind = RZ_TYPE_KIND_CALLABLE;
type->callable = callable;
return type;
}
/**
* \brief Creates new callable based on the name
*
* If the name matches with the name of one of the base types
* that are in the hashtable of the existing types in the parser
* state, then it creates new RzType with the found RzCallable as a base.
*
* In case of the callable found in the hashtable the ownership transfer
* doesn't happen. If not - it does.
*
* \param state The parser state
* \param name Name of the callable type to create
*/
RZ_OWN RzType *c_parser_new_callable(CParserState *state, RZ_NONNULL const char *name) {
rz_return_val_if_fail(state && name, NULL);
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
// We check if there is already a callable in the hashtable with the same name
bool found = false;
RzCallable *callable = ht_pp_find(state->callables, name, &found);
if (!found || !callable) {
// If not found - create a new one
callable = RZ_NEW0(RzCallable);
if (!callable) {
free(type);
return NULL;
}
callable->name = strdup(name);
callable->args = rz_pvector_new((RzPVectorFree)rz_type_callable_arg_free);
}
type->kind = RZ_TYPE_KIND_CALLABLE;
type->callable = callable;
return type;
}
/**
* \brief Adds a new argument to the callable
*
* \param state The parser state
* \param callable Callable type
* \param name Name of the argument
* \param type Type of the argument
*/
bool c_parser_new_callable_argument(CParserState *state, RZ_NONNULL RzCallable *callable, RZ_NONNULL const char *name, RZ_OWN RZ_NONNULL RzType *type) {
rz_return_val_if_fail(state && callable && name && type, false);
// At first we check if there is an argument with the same name already - error if yes
void **it;
rz_pvector_foreach (callable->args, it) {
RzCallableArg *arg = *it;
if (!strcmp(arg->name, name)) {
return false;
}
}
// And only if there is no argument with the same name - proceed to insert it
RzCallableArg *arg = RZ_NEW0(RzCallableArg);
if (!arg) {
return false;
}
arg->name = strdup(name);
arg->type = type;
rz_pvector_push(callable->args, arg);
return true;
}
// Helpers to wrap the ParserTypePair into the pointer or the array complex types
RZ_OWN ParserTypePair *c_parser_type_wrap_to_pointer(CParserState *state, ParserTypePair *tpair, bool is_const) {
rz_return_val_if_fail(state && tpair, NULL);
RzType *type = RZ_NEW0(RzType);
type->kind = RZ_TYPE_KIND_POINTER;
type->pointer.is_const = is_const;
type->pointer.type = tpair->type;
ParserTypePair *newtpair = RZ_NEW0(ParserTypePair);
newtpair->btype = tpair->btype;
newtpair->type = type;
return newtpair;
}
RZ_OWN ParserTypePair *c_parser_type_wrap_to_array(CParserState *state, ParserTypePair *tpair, size_t size) {
rz_return_val_if_fail(state && tpair, NULL);
RzType *type = RZ_NEW0(RzType);
type->kind = RZ_TYPE_KIND_ARRAY;
type->array.count = size;
type->array.type = tpair->type;
ParserTypePair *newtpair = RZ_NEW0(ParserTypePair);
newtpair->btype = tpair->btype;
newtpair->type = type;
return newtpair;
}
bool c_parser_pointer_set_subtype(CParserState *state, RZ_BORROW ParserTypePair *tpair, RZ_OWN ParserTypePair *subpair) {
rz_return_val_if_fail(state && tpair, false);
rz_return_val_if_fail(tpair->type->kind == RZ_TYPE_KIND_POINTER, false);
tpair->type->pointer.type = subpair->type;
tpair->btype = subpair->btype;
return true;
}
bool c_parser_array_set_subtype(CParserState *state, RZ_BORROW ParserTypePair *tpair, RZ_OWN ParserTypePair *subpair) {
rz_return_val_if_fail(state && tpair, false);
rz_return_val_if_fail(tpair->type->kind == RZ_TYPE_KIND_ARRAY, false);
tpair->type->array.type = subpair->type;
tpair->btype = subpair->btype;
return true;
}
RZ_OWN char *c_parser_new_anonymous_structure_name(CParserState *state) {
char *name = rz_str_newf("anonymous struct %zu", state->anon.structs);
state->anon.structs++;
return name;
}
RZ_OWN char *c_parser_new_anonymous_union_name(CParserState *state) {
char *name = rz_str_newf("anonymous union %zu", state->anon.unions);
state->anon.unions++;
return name;
}
RZ_OWN char *c_parser_new_anonymous_enum_name(CParserState *state) {
char *name = rz_str_newf("anonymous enum %zu", state->anon.enums);
state->anon.enums++;
return name;
}
RZ_OWN char *c_parser_new_anonymous_callable_name(CParserState *state) {
char *name = rz_str_newf("anonymous function %zu", state->anon.callables);
state->anon.enums++;
return name;
}
rizin-0.7.4/librz/type/parser/c_cpp_parser.c 0000664 0001750 0001750 00000036367 14731035230 020437 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#include
#include
#include
#define TS_START_END(node, start, end) \
do { \
start = ts_node_start_byte(node); \
end = ts_node_end_byte(node); \
} while (0)
static char *ts_node_sub_string(TSNode node, const char *cstr) {
ut32 start, end;
TS_START_END(node, start, end);
return rz_str_newf("%.*s", end - start, cstr + start);
}
// Declare the `tree_sitter_c` function, which is
// implemented by the `tree-sitter-c` library.
TSLanguage *tree_sitter_c();
// Declare the `tree_sitter_cpp` function, which is
// implemented by the `tree-sitter-cpp` library.
// TSLanguage *tree_sitter_cpp();
CParserState *c_parser_state_new(HtPP *base_types, HtPP *callable_types) {
CParserState *state = RZ_NEW0(CParserState);
if (!base_types) {
state->types = ht_pp_new0();
} else {
state->types = base_types;
}
if (!callable_types) {
state->callables = ht_pp_new0();
} else {
state->callables = callable_types;
}
// Forward definitions require to have a special hashtable
state->forward = ht_pp_new0();
// Initializing error/warning/debug messages buffers
state->errors = rz_strbuf_new("");
state->warnings = rz_strbuf_new("");
state->debug = rz_strbuf_new("");
state->verbose = false;
return state;
}
void c_parser_state_free(CParserState *state) {
ht_pp_free(state->forward);
ht_pp_free(state->types);
ht_pp_free(state->callables);
rz_strbuf_free(state->debug);
rz_strbuf_free(state->warnings);
rz_strbuf_free(state->errors);
free(state);
return;
}
void c_parser_state_free_keep_ht(CParserState *state) {
ht_pp_free(state->forward);
rz_strbuf_free(state->debug);
rz_strbuf_free(state->warnings);
rz_strbuf_free(state->errors);
free(state);
return;
}
void c_parser_state_reset_keep_ht(CParserState *state) {
rz_strbuf_free(state->debug);
rz_strbuf_free(state->warnings);
rz_strbuf_free(state->errors);
// Initializing error/warning/debug messages buffers
state->errors = rz_strbuf_new("");
state->warnings = rz_strbuf_new("");
state->debug = rz_strbuf_new("");
return;
}
struct rz_type_parser_t {
CParserState *state;
};
/**
* \brief Creates a new instance of the C type parser
*
* Creates the new instance of the C types parser with empty
* hashtables for RzBaseTypes and RzCallable types.
*/
RZ_API RZ_OWN RzTypeParser *rz_type_parser_new() {
RzTypeParser *parser = RZ_NEW0(RzTypeParser);
if (!parser) {
return NULL;
}
parser->state = c_parser_state_new(NULL, NULL);
return parser;
}
/**
* \brief Creates a new instance of the C type parser
*
* Creates the new instance of the C types parser preloaded
* hashtables for RzBaseTypes and RzCallable types. It will
* use provided hashtables for storing the parsed types as well.
*
* \param type RzBaseTypes hashtable to preload into the parser state
* \param type RzCallable hashtable to preload into the parser state
*/
RZ_API RZ_OWN RzTypeParser *rz_type_parser_init(HtPP *types, HtPP *callables) {
RzTypeParser *parser = RZ_NEW0(RzTypeParser);
if (!parser) {
return NULL;
}
parser->state = c_parser_state_new(types, callables);
return parser;
}
/**
* \brief Frees the instance of the C type parser without destroying hashtables
*/
RZ_API void rz_type_parser_free(RZ_NONNULL RzTypeParser *parser) {
// We do not destroy HT by default since it might be used after
c_parser_state_free_keep_ht(parser->state);
free(parser);
}
/**
* \brief Frees the instance of the C type parser and destroy the hashtables
*/
RZ_API void rz_type_parser_free_purge(RZ_NONNULL RzTypeParser *parser) {
c_parser_state_free(parser->state);
free(parser);
}
static int type_parse_string(CParserState *state, const char *code, char **error_msg) {
// Create a parser.
TSParser *parser = ts_parser_new();
// Set the parser's language (C in this case)
ts_parser_set_language(parser, tree_sitter_c());
TSTree *tree = ts_parser_parse_string(parser, NULL, code, strlen(code));
// Get the root node of the syntax tree.
TSNode root_node = ts_tree_root_node(tree);
int root_node_child_count = ts_node_named_child_count(root_node);
if (!root_node_child_count) {
parser_warning(state, "Root node is empty!\n");
ts_tree_delete(tree);
ts_parser_delete(parser);
return 0;
}
// Some debugging
if (state->verbose) {
parser_debug(state, "root_node (%d children): %s\n", root_node_child_count, ts_node_type(root_node));
// Print the syntax tree as an S-expression.
char *string = ts_node_string(root_node);
parser_debug(state, "Syntax tree: %s\n", string);
free(string);
}
// At first step we should handle defines
// #define
// #if / #ifdef
// #else
// #endif
// After that, we should process include files and #error/#warning/#pragma
// Temporarily we could just run preprocessing step using tccpp code
//
// And only after that - run the normal C/C++ syntax parsing
// Filter types function prototypes and start parsing
int i = 0, result = 0;
for (i = 0; i < root_node_child_count; i++) {
TSNode child = ts_node_named_child(root_node, i);
// We skip ";" or "," - empty expressions
char *node_code = ts_node_sub_string(child, code);
if (!strcmp(node_code, ";") || !strcmp(node_code, ",")) {
free(node_code);
continue;
}
free(node_code);
parser_debug(state, "Processing %d child...\n", i);
result += parse_type_nodes_save(state, child, code);
}
// If there were errors during the parser then the result is different from 0
if (result) {
char *error_msgs = rz_strbuf_drain_nofree(state->errors);
RZ_LOG_DEBUG("Errors:\n");
RZ_LOG_DEBUG("%s", error_msgs);
char *warning_msgs = rz_strbuf_drain_nofree(state->warnings);
RZ_LOG_DEBUG("Warnings:\n");
RZ_LOG_DEBUG("%s", warning_msgs);
if (error_msg) {
*error_msg = strdup(error_msgs);
}
free(error_msgs);
free(warning_msgs);
}
if (state->verbose) {
char *debug_msgs = rz_strbuf_drain_nofree(state->debug);
RZ_LOG_DEBUG("%s", debug_msgs);
free(debug_msgs);
}
// After everything parsed, we should preserve the base type database
// And the state of the parser - anonymous structs, forward declarations, etc
ts_tree_delete(tree);
ts_parser_delete(parser);
return result;
}
/**
* \brief Parses the C type string reusing the existing parser state
*
* \param parser RzTypeParser instance
* \param code The C type itself
* \param error_msg A pointer where all error messages will be stored
*/
RZ_API int rz_type_parse_string_stateless(RzTypeParser *parser, const char *code, char **error_msg) {
return type_parse_string(parser->state, code, error_msg);
}
/**
* \brief Parses the C types file reusing the existing parser state
*
* \param parser RzTypeParser instance
* \param path The path to the C file to parse
* \param dir The directory where the C file is located
* \param error_msg A pointer where all error messages will be stored
*/
RZ_API int rz_type_parse_file_stateless(RzTypeParser *parser, const char *path, const char *dir, char **error_msg) {
size_t read_bytes = 0;
char *source_code = rz_file_slurp(path, &read_bytes);
if (!source_code || !read_bytes) {
free(source_code);
return -1;
}
RZ_LOG_DEBUG("File size is %" PFMT64d " bytes, read %zu bytes\n", rz_file_size(path), read_bytes);
int result = rz_type_parse_string_stateless(parser, source_code, error_msg);
free(source_code);
return result;
}
/**
* \brief Parses the C types file creating the new parser state
*
* \param typedb RzTypeDB instance
* \param path The path to the C file to parse
* \param dir The directory where the C file is located
* \param error_msg A pointer where all error messages will be stored
*/
RZ_API int rz_type_parse_file(RzTypeDB *typedb, const char *path, const char *dir, char **error_msg) {
size_t read_bytes = 0;
char *source_code = rz_file_slurp(path, &read_bytes);
if (!source_code || !read_bytes) {
free(source_code);
return -1;
}
RZ_LOG_DEBUG("File size is %" PFMT64d " bytes, read %zu bytes\n", rz_file_size(path), read_bytes);
int result = rz_type_parse_string(typedb, source_code, error_msg);
free(source_code);
return result;
}
/**
* \brief Parses the C type string creating the new parser state
*
* \param typedb RzTypeDB instance
* \param code The C type itself
* \param error_msg A pointer where all error messages will be stored
*/
RZ_API int rz_type_parse_string(RzTypeDB *typedb, const char *code, char **error_msg) {
bool verbose = true;
// Create new C parser state
CParserState *state = c_parser_state_new(typedb->types, typedb->callables);
if (!state) {
eprintf("CParserState initialization error!\n");
return -1;
}
state->verbose = verbose;
int ret = type_parse_string(state, code, error_msg);
c_parser_state_free_keep_ht(state);
return ret;
}
/**
* \brief Reset the C parser state
*
* \param typedb RzTypeDB instance
*/
RZ_API void rz_type_parse_reset(RzTypeDB *typedb) {
rz_type_parser_free(typedb->parser);
typedb->parser = rz_type_parser_new();
}
/**
* \brief Parses the single C type definition
*
* \param parser RzTypeParser parser instance
* \param code The C type itself
* \param error_msg A pointer where all error messages will be stored
*/
RZ_API RZ_OWN RzType *rz_type_parse_string_single(RzTypeParser *parser, const char *code, char **error_msg) {
rz_return_val_if_fail(parser && code, NULL);
if (error_msg) {
*error_msg = NULL;
}
// Create a parser.
TSParser *tsparser = ts_parser_new();
// Set the parser's language (C in this case)
ts_parser_set_language(tsparser, tree_sitter_c());
// Note, that the original C grammar doesn't have support for alternate roots,
// see:
// - https://github.com/tree-sitter/tree-sitter-c/issues/65
// - https://github.com/tree-sitter/tree-sitter/issues/1105
// Thus, we use our own patched C grammar that has an additional rule
// for type descriptor, but we use the `__TYPE_EXPRESSION` prefix for every
// such type descriptor expression.
char *patched_code = rz_str_newf("__TYPE_EXPRESSION %s", code);
TSTree *tree = ts_parser_parse_string(tsparser, NULL, patched_code, strlen(patched_code));
// Get the root node of the syntax tree.
TSNode root_node = ts_tree_root_node(tree);
int root_node_child_count = ts_node_named_child_count(root_node);
if (!root_node_child_count) {
parser_warning(parser->state, "Root node is empty!\n");
ts_tree_delete(tree);
ts_parser_delete(tsparser);
free(patched_code);
return NULL;
}
// Some debugging
if (parser->state->verbose) {
parser_debug(parser->state, "code: \"%s\"\n", code);
parser_debug(parser->state, "patched code: \"%s\"\n", patched_code);
parser_debug(parser->state, "root_node (%d children): %s\n", root_node_child_count, ts_node_type(root_node));
// Print the syntax tree as an S-expression.
char *string = ts_node_string(root_node);
parser_debug(parser->state, "Syntax tree: %s\n", string);
free(string);
}
// At first step we should handle defines
// #define
// #if / #ifdef
// #else
// #endif
// After that, we should process include files and #error/#warning/#pragma
// Temporarily we could just run preprocessing step using tccpp code
//
// And only after that - run the normal C/C++ syntax parsing
// Filter types function prototypes and start parsing
int i = 0, result = 0;
ParserTypePair *tpair = NULL;
for (i = 0; i < root_node_child_count; i++) {
parser_debug(parser->state, "Processing %d child...\n", i);
TSNode child = ts_node_named_child(root_node, i);
if (!parse_type_descriptor_single(parser->state, child, patched_code, &tpair)) {
break;
}
}
// If there were errors during the parser then the result is different from 0
if (result || !tpair) {
char *error_msgs = rz_strbuf_drain_nofree(parser->state->errors);
RZ_LOG_DEBUG("Errors:\n");
RZ_LOG_DEBUG("%s", error_msgs);
char *warning_msgs = rz_strbuf_drain_nofree(parser->state->warnings);
RZ_LOG_DEBUG("Warnings:\n");
RZ_LOG_DEBUG("%s", warning_msgs);
if (error_msg) {
*error_msg = strdup(error_msgs);
}
free(error_msgs);
free(warning_msgs);
}
if (parser->state->verbose) {
char *debug_msgs = rz_strbuf_drain_nofree(parser->state->debug);
RZ_LOG_DEBUG("%s", debug_msgs);
free(debug_msgs);
}
// After everything parsed, we should preserve the base type database
// Also we don't free the parser state, just reset the buffers for new use
c_parser_state_reset_keep_ht(parser->state);
ts_tree_delete(tree);
ts_parser_delete(tsparser);
free(patched_code);
RzType *ret = tpair ? tpair->type : NULL;
free(tpair);
return ret;
}
/**
* \brief Parses the single C type declaration
*
* \param parser RzTypeParser parser instance
* \param code The C type itself
* \param error_msg A pointer where all error messages will be stored
*/
RZ_API RZ_OWN RzType *rz_type_parse_string_declaration_single(RzTypeParser *parser, const char *code, char **error_msg) {
if (error_msg) {
*error_msg = NULL;
}
// Create a parser.
TSParser *tsparser = ts_parser_new();
// Set the parser's language (C in this case)
ts_parser_set_language(tsparser, tree_sitter_c());
TSTree *tree = ts_parser_parse_string(tsparser, NULL, code, strlen(code));
// Get the root node of the syntax tree.
TSNode root_node = ts_tree_root_node(tree);
int root_node_child_count = ts_node_named_child_count(root_node);
if (!root_node_child_count) {
parser_warning(parser->state, "Root node is empty!\n");
ts_tree_delete(tree);
ts_parser_delete(tsparser);
return NULL;
}
// Some debugging
if (parser->state->verbose) {
parser_debug(parser->state, "code: \"%s\"\n", code);
parser_debug(parser->state, "root_node (%d children): %s\n", root_node_child_count, ts_node_type(root_node));
// Print the syntax tree as an S-expression.
char *string = ts_node_string(root_node);
parser_debug(parser->state, "Syntax tree: %s\n", string);
free(string);
}
// At first step we should handle defines
// #define
// #if / #ifdef
// #else
// #endif
// After that, we should process include files and #error/#warning/#pragma
// Temporarily we could just run preprocessing step using tccpp code
//
// And only after that - run the normal C/C++ syntax parsing
// Filter types function prototypes and start parsing
int i = 0, result = 0;
ParserTypePair *tpair = NULL;
for (i = 0; i < root_node_child_count; i++) {
parser_debug(parser->state, "Processing %d child...\n", i);
TSNode child = ts_node_named_child(root_node, i);
if (!parse_declaration_node(parser->state, child, code, &tpair)) {
break;
}
}
// If there were errors during the parser then the result is different from 0
if (result || !tpair) {
char *error_msgs = rz_strbuf_drain_nofree(parser->state->errors);
RZ_LOG_DEBUG("Errors:\n");
RZ_LOG_DEBUG("%s", error_msgs);
char *warning_msgs = rz_strbuf_drain_nofree(parser->state->warnings);
RZ_LOG_DEBUG("Warnings:\n");
RZ_LOG_DEBUG("%s", warning_msgs);
if (error_msg) {
*error_msg = strdup(error_msgs);
}
free(error_msgs);
free(warning_msgs);
}
if (parser->state->verbose) {
char *debug_msgs = rz_strbuf_drain_nofree(parser->state->debug);
RZ_LOG_DEBUG("%s", debug_msgs);
free(debug_msgs);
}
// After everything parsed, we should preserve the base type database
// Also we don't free the parser state, just reset the buffers for new use
c_parser_state_reset_keep_ht(parser->state);
ts_tree_delete(tree);
ts_parser_delete(tsparser);
return tpair ? tpair->type : NULL;
}
rizin-0.7.4/librz/type/type.c 0000664 0001750 0001750 00000121637 14731035230 015457 0 ustar sophie sophie // SPDX-FileCopyrightText: 2013-2020 sivaramaaa
// SPDX-FileCopyrightText: 2013-2020 pancake
// SPDX-FileCopyrightText: 2013-2020 oddcoder
// SPDX-FileCopyrightText: 2019-2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
static void types_ht_free(HtPPKv *kv) {
free(kv->key);
rz_type_base_type_free(kv->value);
}
static void types_ht_free_keep_val(HtPPKv *kv) {
free(kv->key);
}
static void formats_ht_free(HtPPKv *kv) {
free(kv->key);
free(kv->value);
}
static void callables_ht_free(HtPPKv *kv) {
free(kv->key);
rz_type_callable_free(kv->value);
}
/**
* \brief Creates a new instance of the RzTypeDB
*
* Creates the RzTypeDB instance, initializes
* hashtables for RzBaseType, RzCallable, type formats.
* Also initializes default "target" (arch, bits, platform) parameters.
*/
RZ_API RzTypeDB *rz_type_db_new() {
RzTypeDB *typedb = RZ_NEW0(RzTypeDB);
if (!typedb) {
return NULL;
}
typedb->target = RZ_NEW0(RzTypeTarget);
if (!typedb->target) {
free(typedb);
return NULL;
}
typedb->target->default_type = strdup("int");
typedb->types = ht_pp_new(NULL, types_ht_free, NULL);
if (!typedb->types) {
goto rz_type_db_new_fail;
}
typedb->formats = ht_pp_new(NULL, formats_ht_free, NULL);
if (!typedb->formats) {
goto rz_type_db_new_fail;
}
typedb->callables = ht_pp_new(NULL, callables_ht_free, NULL);
if (!typedb->callables) {
goto rz_type_db_new_fail;
}
typedb->parser = rz_type_parser_init(typedb->types, typedb->callables);
if (!typedb->parser) {
goto rz_type_db_new_fail;
}
rz_io_bind_init(typedb->iob);
return typedb;
rz_type_db_new_fail:
free((void *)typedb->target->default_type);
free(typedb->target);
ht_pp_free(typedb->types);
ht_pp_free(typedb->formats);
ht_pp_free(typedb->callables);
free(typedb);
return NULL;
}
/**
* \brief Frees the instance of the RzTypeDB
*
* Destroys hashtables for RzBaseType, RzCallable, type formats.
*/
RZ_API void rz_type_db_free(RzTypeDB *typedb) {
rz_type_parser_free(typedb->parser);
ht_pp_free(typedb->callables);
ht_pp_free(typedb->types);
ht_pp_free(typedb->formats);
free((void *)typedb->target->default_type);
free(typedb->target->os);
free(typedb->target->cpu);
free(typedb->target);
free(typedb);
}
/**
* \brief Purges the instance of the RzTypeDB
*
* Destroys all loaded base types and callable types.
*/
RZ_API void rz_type_db_purge(RzTypeDB *typedb) {
ht_pp_free(typedb->callables);
typedb->callables = ht_pp_new(NULL, callables_ht_free, NULL);
ht_pp_free(typedb->types);
typedb->types = ht_pp_new(NULL, types_ht_free, NULL);
rz_type_parser_free(typedb->parser);
typedb->parser = rz_type_parser_init(typedb->types, typedb->callables);
}
/**
* \brief Purges formats in the instance of the RzTypeDB
*/
RZ_API void rz_type_db_format_purge(RzTypeDB *typedb) {
ht_pp_free(typedb->formats);
typedb->formats = ht_pp_new(NULL, formats_ht_free, NULL);
}
static void set_default_type(RzTypeTarget *target, int bits) {
if (target->default_type) {
free((void *)target->default_type);
}
switch (bits) {
case 8:
target->default_type = strdup("int8_t");
break;
case 16:
target->default_type = strdup("int16_t");
break;
case 32:
target->default_type = strdup("int32_t");
break;
case 64:
target->default_type = strdup("int64_t");
break;
default:
rz_warn_if_reached();
target->default_type = strdup("int");
}
}
/**
* \brief Set the RzType target architecture bits
*
* Important for calculating some types size, especially
* pointers's size.
*
* \param typedb RzTypeDB instance
* \param bits Architecture bits to set
*/
RZ_API void rz_type_db_set_bits(RzTypeDB *typedb, int bits) {
typedb->target->bits = bits;
// Also set the new default type
set_default_type(typedb->target, bits);
}
/**
* \brief Set the RzType target adress size
*
* Important for calculating some types size, especially
* pointers's size.
*
* \param typedb RzTypeDB instance
* \param bits size of an address in bits. If <= 0, then
* the value from rz_type_db_set_bits() is used.
*/
RZ_API void rz_type_db_set_address_bits(RzTypeDB *typedb, int addr_bits) {
rz_return_if_fail(typedb);
typedb->target->addr_bits = addr_bits;
}
/**
* \brief Set the RzType target architecture operating system
*
* Important for calculating some types size, especially
* pointers's size.
*
* \param typedb RzTypeDB instance
* \param os Operating system name to set
*/
RZ_API void rz_type_db_set_os(RzTypeDB *typedb, const char *os) {
free(typedb->target->os);
typedb->target->os = os ? strdup(os) : NULL;
}
/**
* \brief Set the RzType target architecture CPU
*
* Important for calculating some types size, especially
* pointers's size.
*
* \param typedb RzTypeDB instance
* \param cpu Architecture name to set
*/
RZ_API void rz_type_db_set_cpu(RzTypeDB *typedb, const char *cpu) {
free(typedb->target->cpu);
typedb->target->cpu = cpu ? strdup(cpu) : NULL;
}
/**
* \brief Set the RzType target architecture CPU
*
* Important for calculating complex types layout.
*
* \param typedb RzTypeDB instance
* \param big_endian True if the big endian, false if the opposite
*/
RZ_API void rz_type_db_set_endian(RzTypeDB *typedb, bool big_endian) {
typedb->target->big_endian = big_endian;
}
/**
* \brief Returns the pointer size for the current RzTypeDB target set
*
* \param typedb RzTypeDB instance
*/
RZ_API ut8 rz_type_db_pointer_size(const RzTypeDB *typedb) {
return typedb->target->addr_bits > 0 ? typedb->target->addr_bits : typedb->target->bits;
}
/**
* \brief Removes the type from the database.
*
* Can remove either RzBaseType or RzCallable type
*
* \param typedb RzTypeDB instance
* \param name RzBaseType or RzCallable type name
*/
RZ_API bool rz_type_db_del(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, false);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
if (!rz_type_func_exist(typedb, name)) {
eprintf("Unrecognized type \"%s\"\n", name);
return false;
}
rz_type_func_delete(typedb, name);
return true;
}
rz_type_db_delete_base_type(typedb, btype);
return true;
}
/**
* \brief Initializes the types database for specified arch, bits, OS
*
* Loads pre-shipped type libraries for base types and function types.
* Different architectures, operating systems, bitness affects
* on what exact types are loaded, also some atomic types sizes are different.
* In some cases the same type, for example, structure type could have
* a different layout, depending on the operating system or bitness.
*
* \param typedb Types Database instance
* \param types_dir Directory where all type libraries are installed
* \param arch Architecture of the analysis session
* \param bits Bitness of the analysis session
* \param os Operating system of the analysis session
*/
RZ_API void rz_type_db_init(RzTypeDB *typedb, const char *types_dir, const char *arch, int bits, const char *os) {
rz_return_if_fail(typedb && typedb->types && typedb->formats);
// A workaround to fix loading incorrectly detected MacOS binaries
if (RZ_STR_ISNOTEMPTY(os) && !strcmp(os, "darwin")) {
os = "macos";
}
// At first we load the basic types
// Atomic types
char *dbpath = rz_file_path_join(types_dir, "types-atomic.sdb");
if (rz_type_db_load_sdb(typedb, dbpath)) {
RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
}
free(dbpath);
// C runtime types
dbpath = rz_file_path_join(types_dir, "types-libc.sdb");
if (rz_type_db_load_sdb(typedb, dbpath)) {
RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
}
free(dbpath);
// We do not load further if bits are not specified
if (bits <= 0) {
return;
}
// Bits-specific types that are independent from architecture or OS
char tmp[100];
dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%d.sdb", bits));
if (rz_type_db_load_sdb(typedb, dbpath)) {
RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
}
free(dbpath);
// We do not load further if architecture is not specified
if (!arch) {
return;
}
// Architecture-specific types
dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s.sdb", arch));
if (rz_type_db_load_sdb(typedb, dbpath)) {
RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
}
free(dbpath);
// Architecture- and bits-specific types
dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s-%d.sdb", arch, bits));
if (rz_type_db_load_sdb(typedb, dbpath)) {
RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
}
free(dbpath);
if (os) {
// OS-specific types
dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s.sdb", os));
if (rz_type_db_load_sdb(typedb, dbpath)) {
RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
}
free(dbpath);
dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s-%d.sdb", os, bits));
if (rz_type_db_load_sdb(typedb, dbpath)) {
RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
}
free(dbpath);
dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s-%s.sdb", arch, os));
if (rz_type_db_load_sdb(typedb, dbpath)) {
RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
}
free(dbpath);
dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "types-%s-%s-%d.sdb", arch, os, bits));
if (rz_type_db_load_sdb(typedb, dbpath)) {
RZ_LOG_DEBUG("types: loaded \"%s\"\n", dbpath);
}
free(dbpath);
}
// Then, after all basic types are initialized, we load function types
// that use loaded previously base types for return and arguments
dbpath = rz_file_path_join(types_dir, "functions-libc.sdb");
if (rz_type_db_load_callables_sdb(typedb, dbpath)) {
RZ_LOG_DEBUG("callable types: loaded \"%s\"\n", dbpath);
}
free(dbpath);
// OS-specific function types
if (os) {
dbpath = rz_file_path_join(types_dir, rz_strf(tmp, "functions-%s.sdb", os));
if (rz_type_db_load_callables_sdb(typedb, dbpath)) {
RZ_LOG_DEBUG("callable types: loaded \"%s\"\n", dbpath);
}
free(dbpath);
}
}
/**
* \brief Re-initializes the types database for current target
*
* Similarly to rz_type_db_init loads pre-shipped type libraries
* for base types and function types.
*
* \param typedb Types Database instance
* \param types_dir Directory where all type libraries are installed
*/
RZ_API void rz_type_db_reload(RzTypeDB *typedb, const char *types_dir) {
rz_type_db_init(typedb, types_dir, typedb->target->cpu, typedb->target->bits, typedb->target->os);
}
// Listing all available types by category
/**
* \brief Returns the list of all enum names
*
* \param typedb Types Database instance
*/
RZ_API RZ_OWN RzList /**/ *rz_type_db_enum_names(RzTypeDB *typedb) {
rz_return_val_if_fail(typedb, NULL);
RzList *enums = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_ENUM);
RzList *result = rz_list_new();
RzListIter *iter;
RzBaseType *e;
rz_list_foreach (enums, iter, e) {
rz_list_append(result, e->name);
}
rz_list_free(enums);
return result;
}
/**
* \brief Returns the list of all union names
*
* \param typedb Types Database instance
*/
RZ_API RZ_OWN RzList /**/ *rz_type_db_union_names(RzTypeDB *typedb) {
rz_return_val_if_fail(typedb, NULL);
RzList *unions = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_UNION);
RzList *result = rz_list_new();
RzListIter *iter;
RzBaseType *u;
rz_list_foreach (unions, iter, u) {
rz_list_append(result, u->name);
}
rz_list_free(unions);
return result;
}
/**
* \brief Returns the list of all struct names
*
* \param typedb Types Database instance
*/
RZ_API RZ_OWN RzList /**/ *rz_type_db_struct_names(RzTypeDB *typedb) {
rz_return_val_if_fail(typedb, NULL);
RzList *structs = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_STRUCT);
RzList *result = rz_list_new();
RzListIter *iter;
RzBaseType *s;
rz_list_foreach (structs, iter, s) {
rz_list_append(result, s->name);
}
rz_list_free(structs);
return result;
}
/**
* \brief Returns the list of all typedef (type aliases) names
*
* \param typedb Types Database instance
*/
RZ_API RZ_OWN RzList /**/ *rz_type_db_typedef_names(RzTypeDB *typedb) {
rz_return_val_if_fail(typedb, NULL);
RzList *typedefs = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_TYPEDEF);
RzList *result = rz_list_new();
RzListIter *iter;
RzBaseType *t;
rz_list_foreach (typedefs, iter, t) {
rz_list_append(result, t->name);
}
rz_list_free(typedefs);
return result;
}
/**
* \brief Returns the list of all type names
*
* \param typedb Types Database instance
*/
RZ_API RZ_OWN RzList /**/ *rz_type_db_all(RzTypeDB *typedb) {
rz_return_val_if_fail(typedb, NULL);
RzList *types = rz_type_db_get_base_types(typedb);
RzList *result = rz_list_new();
RzListIter *iter;
RzBaseType *t;
rz_list_foreach (types, iter, t) {
rz_list_append(result, t->name);
}
rz_list_free(types);
return result;
}
// Type-specific APIs
/**
* \brief Checks if the type exists in the Type database
*
* \param typedb Types Database instance
* \param name Name of the type
*/
RZ_API bool rz_type_exists(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, -1);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
return btype != NULL;
}
/**
* \brief Returns the kind (RzBaseTypeKind) of the type
*
* \param typedb Types Database instance
* \param name Name of the type
*/
RZ_API int rz_type_kind(RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, -1);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return -1;
}
return btype->kind;
}
/**
* \brief Returns the enum base type matching the specified name
*
* \param typedb Types Database instance
* \param name The name of the enum to match against
*/
RZ_API RzBaseType *rz_type_db_get_enum(const RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, NULL);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return NULL;
}
if (btype->kind != RZ_BASE_TYPE_KIND_ENUM) {
return NULL;
}
return btype;
}
/**
* \brief Returns the enum case name matching the cpecified value
*
* \param typedb Types Database instance
* \param name The name of the enum to search in
* \param val The value to search for
*/
RZ_API RZ_BORROW const char *rz_type_db_enum_member_by_val(const RzTypeDB *typedb, RZ_NONNULL const char *name, ut64 val) {
rz_return_val_if_fail(typedb && name, NULL);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return NULL;
}
if (btype->kind != RZ_BASE_TYPE_KIND_ENUM) {
return NULL;
}
RzTypeEnumCase *cas;
rz_vector_foreach(&btype->enum_data.cases, cas) {
if (cas->val == val) {
return cas->name;
}
}
return NULL;
}
/**
* \brief Returns the enum case value matched by the enum case name
*
* \param typedb Types Database instance
* \param name The name of the enum to search in
* \param member The enum case name to search for
*/
RZ_API int rz_type_db_enum_member_by_name(const RzTypeDB *typedb, RZ_NONNULL const char *name, const char *member) {
rz_return_val_if_fail(typedb && name, -1);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return -1;
}
if (btype->kind != RZ_BASE_TYPE_KIND_ENUM) {
return -1;
}
RzTypeEnumCase *cas;
int result = -1;
rz_vector_foreach(&btype->enum_data.cases, cas) {
if (!strcmp(cas->name, member)) {
result = cas->val;
break;
}
}
return result;
}
/**
* \brief Returns all enums and cases name matching the specified value
*
* \param typedb Types Database instance
* \param val The value to search for
*/
RZ_API RZ_OWN RzList /**/ *rz_type_db_find_enums_by_val(const RzTypeDB *typedb, ut64 val) {
rz_return_val_if_fail(typedb, NULL);
RzList *enums = rz_type_db_get_base_types_of_kind(typedb, RZ_BASE_TYPE_KIND_ENUM);
RzList *result = rz_list_newf(free);
RzListIter *iter;
RzBaseType *e;
rz_list_foreach (enums, iter, e) {
RzTypeEnumCase *cas;
rz_vector_foreach(&e->enum_data.cases, cas) {
if (cas->val == val) {
rz_list_append(result, rz_str_newf("%s.%s", e->name, cas->name));
}
}
}
rz_list_free(enums);
return result;
}
/**
* \brief Returns all matching bitfields as an OR mask given the resulting value
*
* \param typedb Types Database instance
* \param name The name of the bitfield enum
* \param val The value to search for
*/
RZ_API RZ_OWN char *rz_type_db_enum_get_bitfield(const RzTypeDB *typedb, RZ_NONNULL const char *name, ut64 val) {
rz_return_val_if_fail(typedb && name, NULL);
char *res = NULL;
int i;
bool isFirst = true;
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return NULL;
}
if (btype->kind != RZ_BASE_TYPE_KIND_ENUM) {
return NULL;
}
char *ret = rz_str_newf("0x%08" PFMT64x " : ", val);
for (i = 0; i < 32; i++) {
ut32 n = 1ULL << i;
if (!(val & n)) {
continue;
}
RzTypeEnumCase *cas;
rz_vector_foreach(&btype->enum_data.cases, cas) {
if (cas->val == n) {
res = cas->name;
break;
}
}
if (isFirst) {
isFirst = false;
} else {
ret = rz_str_append(ret, " | ");
}
if (res) {
ret = rz_str_append(ret, res);
} else {
ret = rz_str_appendf(ret, "0x%x", n);
}
}
return ret;
}
/**
* \brief Returns the union base type matching the specified name
*
* \param typedb Types Database instance
* \param name The name of the union to match against
*/
RZ_API RzBaseType *rz_type_db_get_union(const RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, NULL);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return NULL;
}
if (btype->kind != RZ_BASE_TYPE_KIND_UNION) {
return NULL;
}
return btype;
}
/**
* \brief returns the struct base type matching the specified name
*
* \param typedb types database instance
* \param name the name of the struct to match against
*/
RZ_API RzBaseType *rz_type_db_get_struct(const RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, NULL);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return NULL;
}
if (btype->kind != RZ_BASE_TYPE_KIND_STRUCT) {
return NULL;
}
return btype;
}
/**
* \brief Returns the typedef base type matching the specified name
*
* \param typedb Types Database instance
* \param name The name of the typedef to match against
*/
RZ_API RzBaseType *rz_type_db_get_typedef(const RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, NULL);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return NULL;
}
if (btype->kind != RZ_BASE_TYPE_KIND_TYPEDEF) {
return NULL;
}
return btype;
}
static ut64 type_get_bitsize_recurse(const RzTypeDB *typedb, RZ_NONNULL RzType *type, RZ_NULLABLE RzPVector /**/ *visited_btypes);
static ut64 atomic_bitsize(const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype) {
rz_return_val_if_fail(typedb && btype && btype->kind == RZ_BASE_TYPE_KIND_ATOMIC, 0);
return btype->size;
}
static ut64 enum_bitsize(const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype) {
rz_return_val_if_fail(typedb && btype && btype->kind == RZ_BASE_TYPE_KIND_ENUM, 0);
// FIXME: Need a proper way to determine size of enum
return 32;
}
static ut64 struct_union_bitsize(const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype, RZ_NULLABLE RzPVector /**/ *visited_btypes) {
rz_return_val_if_fail(typedb && btype && (btype->kind == RZ_BASE_TYPE_KIND_STRUCT || btype->kind == RZ_BASE_TYPE_KIND_UNION), 0);
RzPVector visited_btypes_owned; // for detecting self-referential typedefs (maybe in multiple steps)
if (!visited_btypes) {
// Lazy allocation of the visited_btypes stack, only at this point we will actually need it
rz_pvector_init(&visited_btypes_owned, NULL);
visited_btypes = &visited_btypes_owned;
} else {
if (rz_pvector_contains(visited_btypes, btype)) {
// loop detected
return 0;
}
}
rz_pvector_push(visited_btypes, btype);
ut64 size = 0;
if (btype->kind == RZ_BASE_TYPE_KIND_STRUCT) {
RzTypeStructMember *memb;
rz_vector_foreach(&btype->struct_data.members, memb) {
size += type_get_bitsize_recurse(typedb, memb->type, visited_btypes);
}
} else {
RzTypeUnionMember *memb;
// Union has the size of the maximum size of its elements
rz_vector_foreach(&btype->union_data.members, memb) {
size = RZ_MAX(type_get_bitsize_recurse(typedb, memb->type, visited_btypes), size);
}
}
if (visited_btypes == &visited_btypes_owned) {
rz_pvector_fini(&visited_btypes_owned);
} else {
rz_pvector_pop(visited_btypes);
}
return size;
}
static ut64 typedef_bitsize(const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype, RZ_NULLABLE RzPVector /**/ *visited_btypes) {
rz_return_val_if_fail(typedb && btype && btype->kind == RZ_BASE_TYPE_KIND_TYPEDEF, 0);
rz_return_val_if_fail(btype->type, 0);
RzType *unwrapped = rz_type_db_base_type_unwrap_typedef(typedb, btype);
if (!unwrapped) {
return 0;
}
return type_get_bitsize_recurse(typedb, unwrapped, visited_btypes);
}
/**
* \param visited_btypes Stack of struct/union types visited higher up in the recursion, for loop detection
* \return the base type size in bits (target dependent)
*/
static ut64 base_type_get_bitsize_recurse(const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype, RZ_NULLABLE RzPVector /**/ *visited_btypes) {
rz_return_val_if_fail(typedb && btype, 0);
if (btype->kind == RZ_BASE_TYPE_KIND_ENUM) {
return enum_bitsize(typedb, btype);
} else if (btype->kind == RZ_BASE_TYPE_KIND_STRUCT || btype->kind == RZ_BASE_TYPE_KIND_UNION) {
return struct_union_bitsize(typedb, btype, visited_btypes);
} else if (btype->kind == RZ_BASE_TYPE_KIND_ATOMIC) {
return atomic_bitsize(typedb, btype);
} else if (btype->kind == RZ_BASE_TYPE_KIND_TYPEDEF) {
return typedef_bitsize(typedb, btype, visited_btypes);
}
// Should not happen
rz_warn_if_reached();
return 0;
}
/**
* \brief Returns the base type size in bits (target dependent)
*
* \param typedb Types Database instance
* \param btype The base type
*/
RZ_API ut64 rz_type_db_base_get_bitsize(const RzTypeDB *typedb, RZ_NONNULL RzBaseType *btype) {
return base_type_get_bitsize_recurse(typedb, btype, NULL);
}
/**
* \param visited_btypes Stack of struct/union types visited higher up in the recursion, for loop detection
* \return the type size in bits (target dependent)
*/
static ut64 type_get_bitsize_recurse(const RzTypeDB *typedb, RZ_NONNULL RzType *type, RZ_NULLABLE RzPVector /**/ *visited_btypes) {
rz_return_val_if_fail(typedb && type, 0);
// Detect if the pointer and return the corresponding size
if (type->kind == RZ_TYPE_KIND_POINTER || type->kind == RZ_TYPE_KIND_CALLABLE) {
// Note, that function types (RzCallable) are in fact pointers too
return rz_type_db_pointer_size(typedb);
// Detect if the pointer is array, then return the bitsize of the base type
// multiplied to the array size
} else if (type->kind == RZ_TYPE_KIND_ARRAY) {
return type->array.count * type_get_bitsize_recurse(typedb, type->array.type, visited_btypes);
}
// The rest of the logic is for the normal, identifier types
RzBaseType *btype = rz_type_db_get_base_type(typedb, type->identifier.name);
if (!btype) {
return 0;
}
return base_type_get_bitsize_recurse(typedb, btype, visited_btypes);
}
/**
* \brief Returns the type size in bits (target dependent)
*
* \param typedb Types Database instance
* \param type The type
*/
RZ_API ut64 rz_type_db_get_bitsize(const RzTypeDB *typedb, RZ_NONNULL RzType *type) {
return type_get_bitsize_recurse(typedb, type, NULL);
}
/**
* \brief Returns the type C representation
*
* \param typedb Types Database instance
* \param type RzType type
*/
RZ_API RZ_OWN char *rz_type_as_string(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(typedb && type, NULL);
return rz_type_as_pretty_string(typedb, type, NULL, RZ_TYPE_PRINT_ZERO_VLA | RZ_TYPE_PRINT_NO_END_SEMICOLON | RZ_TYPE_PRINT_ANONYMOUS, 0);
}
/**
* \brief Returns the type C declaration representation
*
* \param typedb Types Database instance
* \param type RzType type
*/
RZ_API RZ_OWN char *rz_type_declaration_as_string(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(typedb && type, NULL);
return rz_type_as_pretty_string(typedb, type, NULL, RZ_TYPE_PRINT_ZERO_VLA | RZ_TYPE_PRINT_NO_END_SEMICOLON, 1); // one level unfold
}
/**
* \brief Returns the type C representation with identifier
*
* \param typedb Types Database instance
* \param type RzType type
*/
RZ_API RZ_OWN char *rz_type_identifier_declaration_as_string(const RzTypeDB *typedb, RZ_NONNULL const RzType *type, RZ_NONNULL const char *identifier) {
rz_return_val_if_fail(typedb && type, NULL);
return rz_type_as_pretty_string(typedb, type, identifier, RZ_TYPE_PRINT_ZERO_VLA | RZ_TYPE_PRINT_NO_END_SEMICOLON | RZ_TYPE_PRINT_UNFOLD_ANON_ONLY_STRICT, 1); // one level unfold (for anonymous only)
}
struct PrettyHelperBufs {
RzStrBuf *typename;
RzStrBuf *pointerbuf;
RzStrBuf *arraybuf;
};
static bool type_decl_as_pretty_string(const RzTypeDB *typedb, const RzType *type, HtPP *used_types, struct PrettyHelperBufs phbuf, bool *self_ref, char **self_ref_typename, bool zero_vla, bool print_anon, bool show_typedefs, bool allow_non_exist) {
rz_return_val_if_fail(typedb && type && used_types && self_ref, false);
bool is_anon = false;
switch (type->kind) {
case RZ_TYPE_KIND_IDENTIFIER: {
if (!type->identifier.name) {
return false;
}
is_anon = !strncmp(type->identifier.name, "anonymous ", strlen("anonymous "));
*self_ref = false;
ht_pp_find(used_types, type->identifier.name, self_ref);
*self_ref = *self_ref && !is_anon; // no self_ref for anon types
*self_ref_typename = *self_ref ? strdup(type->identifier.name) : NULL;
RzBaseType *btype = rz_type_db_get_base_type(typedb, type->identifier.name);
if (!btype && !allow_non_exist) {
rz_strbuf_append(phbuf.typename, "unknown_t");
} else if (!btype || btype->kind == RZ_BASE_TYPE_KIND_ATOMIC) {
rz_strbuf_appendf(phbuf.typename, "%s%s", type->identifier.is_const ? "const " : "", type->identifier.name);
} else {
switch (btype->kind) {
case RZ_BASE_TYPE_KIND_STRUCT:
rz_strbuf_appendf(phbuf.typename, "%sstruct", type->identifier.is_const ? "const " : "");
if (!is_anon || print_anon) {
rz_strbuf_appendf(phbuf.typename, " %s", btype->name);
}
break;
case RZ_BASE_TYPE_KIND_UNION:
rz_strbuf_appendf(phbuf.typename, "%sunion", type->identifier.is_const ? "const " : "");
if (!is_anon || print_anon) {
rz_strbuf_appendf(phbuf.typename, " %s", btype->name);
}
break;
case RZ_BASE_TYPE_KIND_ENUM:
rz_strbuf_appendf(phbuf.typename, "%senum", type->identifier.is_const ? "const " : "");
if (!is_anon || print_anon) {
rz_strbuf_appendf(phbuf.typename, " %s", btype->name);
}
break;
case RZ_BASE_TYPE_KIND_TYPEDEF: {
if (show_typedefs) {
char *typestr = rz_type_as_string(typedb, btype->type);
if (!typestr) {
RZ_LOG_ERROR("Failed to get type representation of typedef of base type: %s\n", btype->name);
return false;
}
rz_strbuf_appendf(phbuf.typename, "typedef %s", typestr);
free(typestr);
} else {
rz_strbuf_append(phbuf.typename, btype->name);
}
break;
}
default:
rz_warn_if_reached();
break;
}
}
break;
}
case RZ_TYPE_KIND_POINTER:
if (rz_type_is_callable_ptr_nested(type)) { // function pointers
char *typestr = rz_type_callable_ptr_as_string(typedb, type);
rz_strbuf_append(phbuf.typename, typestr);
free(typestr);
} else {
type_decl_as_pretty_string(typedb, type->pointer.type, used_types, phbuf, self_ref, self_ref_typename,
zero_vla, print_anon, show_typedefs, allow_non_exist);
rz_strbuf_append(phbuf.pointerbuf, "*");
rz_strbuf_appendf(phbuf.pointerbuf, "%s", type->pointer.is_const ? " const " : "");
}
break;
case RZ_TYPE_KIND_ARRAY:
if (type->array.count) {
rz_strbuf_appendf(phbuf.arraybuf, "[%" PFMT64d "]", type->array.count);
} else { // variable length arrays
rz_strbuf_appendf(phbuf.arraybuf, "[%s]", zero_vla ? "0" : "");
}
type_decl_as_pretty_string(typedb, type->array.type, used_types, phbuf, self_ref, self_ref_typename,
zero_vla, print_anon, show_typedefs, allow_non_exist);
break;
case RZ_TYPE_KIND_CALLABLE: {
char *callstr = rz_type_callable_as_string(typedb, type->callable);
rz_strbuf_append(phbuf.typename, callstr);
free(callstr);
break;
}
default:
rz_warn_if_reached();
break;
}
return true;
}
static char *type_as_pretty_string(const RzTypeDB *typedb, const RzType *type, const char *identifier, HtPP *used_types, unsigned int opts, int unfold_level, int indent_level) {
rz_return_val_if_fail(typedb && type, NULL);
if (unfold_level < 0) { // recursion base case
return NULL;
}
bool multiline = opts & RZ_TYPE_PRINT_MULTILINE;
bool anon_only = opts & RZ_TYPE_PRINT_UNFOLD_ANON_ONLY;
bool anon_only_strict = opts & RZ_TYPE_PRINT_UNFOLD_ANON_ONLY_STRICT;
bool zero_vla = opts & RZ_TYPE_PRINT_ZERO_VLA;
bool print_anon = opts & RZ_TYPE_PRINT_ANONYMOUS;
bool no_end_semicolon = opts & RZ_TYPE_PRINT_NO_END_SEMICOLON;
no_end_semicolon = no_end_semicolon && (indent_level == 0); // indent_level needs to be zero for the last semicolon
bool end_newline = opts & RZ_TYPE_PRINT_END_NEWLINE;
end_newline = end_newline && (indent_level == 0); // only append newline for the outer type
bool show_typedefs = opts & RZ_TYPE_PRINT_SHOW_TYPEDEF;
bool allow_non_exist = opts & RZ_TYPE_PRINT_ALLOW_NON_EXISTENT_BASE_TYPE;
if (indent_level == 0) { // for the root type, disregard anon_only
anon_only = false;
}
anon_only = anon_only || anon_only_strict;
bool unfold_all = !anon_only && unfold_level;
bool unfold_anon = unfold_level;
int indent = 0;
char *separator = " ";
if (multiline) {
indent = indent_level; // indent only if multiline
separator = "\n";
}
RzStrBuf *buf = rz_strbuf_new("");
for (int i = 0; i < indent; i++) {
rz_strbuf_append(buf, "\t");
}
RzStrBuf *typename = rz_strbuf_new("");
RzStrBuf *pointer_buf = rz_strbuf_new("");
RzStrBuf *array_buf = rz_strbuf_new("");
struct PrettyHelperBufs phbuf = { typename, pointer_buf, array_buf };
bool self_ref = false;
char *self_ref_typename = NULL;
bool decl = type_decl_as_pretty_string(typedb, type, used_types, phbuf, &self_ref, &self_ref_typename,
zero_vla, print_anon, show_typedefs, allow_non_exist);
if (!decl) {
rz_strbuf_free(buf);
rz_strbuf_free(typename);
rz_strbuf_free(pointer_buf);
rz_strbuf_free(array_buf);
return NULL;
}
if (self_ref) { // in case of self referntial type
unfold_level = 0; // no unfold
unfold_anon = unfold_all = false;
} else if (self_ref_typename) {
ht_pp_insert(used_types, self_ref_typename, NULL); // add the type to the ht
}
RzBaseType *btype = NULL;
bool is_anon = false;
if (type->kind == RZ_TYPE_KIND_IDENTIFIER) {
is_anon = !strncmp(type->identifier.name, "anonymous ", 10);
btype = rz_type_db_get_base_type(typedb, type->identifier.name);
} else if ((type->kind == RZ_TYPE_KIND_POINTER && rz_type_is_callable_ptr_nested(type)) || type->kind == RZ_TYPE_KIND_CALLABLE) {
identifier = NULL; // no need to separately print identifier for function pointers or functions
}
char *typename_str = rz_strbuf_drain(phbuf.typename);
char *pointer_str = rz_strbuf_drain(phbuf.pointerbuf);
char *array_str = rz_strbuf_drain(phbuf.arraybuf);
rz_strbuf_append(buf, typename_str);
if (btype) {
bool not_empty; // to check if no members are present
switch (btype->kind) {
case RZ_BASE_TYPE_KIND_STRUCT:
if (unfold_all || (is_anon && unfold_anon)) {
rz_strbuf_append(buf, " {");
RzTypeStructMember *memb;
not_empty = rz_vector_len(&btype->struct_data.members);
if (not_empty) {
rz_strbuf_appendf(buf, "%s", multiline ? "\n" : " ");
}
rz_vector_foreach(&btype->struct_data.members, memb) {
char *unfold = type_as_pretty_string(typedb, memb->type, memb->name, used_types, opts, unfold_level - 1, indent_level + 1);
rz_strbuf_appendf(buf, "%s%s", unfold, separator);
free(unfold);
}
for (int i = 0; i < indent; i++) {
rz_strbuf_append(buf, "\t");
}
rz_strbuf_append(buf, "}");
}
break;
case RZ_BASE_TYPE_KIND_UNION:
if (unfold_all || (is_anon && unfold_anon)) {
rz_strbuf_append(buf, " {");
RzTypeUnionMember *memb;
not_empty = rz_vector_len(&btype->union_data.members);
if (not_empty) {
rz_strbuf_appendf(buf, "%s", multiline ? "\n" : " ");
}
rz_vector_foreach(&btype->union_data.members, memb) {
char *unfold = type_as_pretty_string(typedb, memb->type, memb->name, used_types, opts, unfold_level - 1, indent_level + 1);
rz_strbuf_appendf(buf, "%s%s", unfold, separator);
free(unfold);
}
for (int i = 0; i < indent; i++) {
rz_strbuf_append(buf, "\t");
}
rz_strbuf_append(buf, "}");
}
break;
case RZ_BASE_TYPE_KIND_ENUM:
if (unfold_all || (is_anon && unfold_anon)) {
RzTypeEnumCase *cas;
rz_strbuf_append(buf, " {");
if (multiline) {
indent++; // no recursive call, so manually need to update indent
}
not_empty = rz_vector_len(&btype->enum_data.cases);
if (not_empty) {
rz_strbuf_appendf(buf, "%s", multiline ? "\n" : " ");
}
rz_vector_foreach(&btype->enum_data.cases, cas) {
for (int i = 0; i < indent; i++) {
rz_strbuf_append(buf, "\t");
}
rz_strbuf_appendf(buf, "%s = 0x%" PFMT64x ",%s", cas->name, cas->val, separator);
}
if (not_empty) {
rz_strbuf_slice(buf, 0, rz_strbuf_length(buf) - 2);
rz_strbuf_append(buf, separator);
}
if (multiline) {
indent--; // restore the original value
}
for (int i = 0; i < indent; i++) {
rz_strbuf_append(buf, "\t");
}
rz_strbuf_append(buf, "}");
}
break;
case RZ_BASE_TYPE_KIND_TYPEDEF:
if (show_typedefs && !rz_type_is_callable_ptr_nested(btype->type)) { // if not a callable
rz_strbuf_appendf(buf, " %s", btype->name);
}
break;
case RZ_BASE_TYPE_KIND_ATOMIC:
break;
default:
rz_warn_if_reached();
break;
}
}
if (rz_str_nlen(pointer_str, 1) != 0 || identifier || rz_str_nlen(array_str, 1) != 0) {
rz_strbuf_append(buf, " "); // add space only if the type is pointer or an array or has an identifier
}
rz_strbuf_appendf(buf, "%s%s%s", pointer_str ? pointer_str : "", identifier ? identifier : "", array_str ? array_str : "");
if (!no_end_semicolon) {
rz_strbuf_append(buf, ";");
}
if (end_newline) {
rz_strbuf_append(buf, "\n");
}
if (self_ref_typename) {
ht_pp_delete(used_types, self_ref_typename);
free(self_ref_typename);
}
free(typename_str);
free(pointer_str);
free(array_str);
char *pretty_type = rz_strbuf_drain(buf);
return pretty_type;
}
/**
* \brief Return a string contining the type pretty printed according to the options provided
*
* \param typedb typedb for the current analysis
* \param type type to be pretty printed
* \param identifier name of the variable of the given type (RZ_NULLABLE)
* \param opts options for pretty printing (see RzTypePrintOpts)
* \param unfold_level level of unfolding to do in case of nested structures/unions (any negative number means maximum unfolding, i.e. INT32_MAX. 0 means no unfolding, just the typename and identifier, if any)
* \return char* string in pretty printed form
*/
RZ_API RZ_OWN char *rz_type_as_pretty_string(const RzTypeDB *typedb, RZ_NONNULL const RzType *type, RZ_NULLABLE const char *identifier, unsigned int opts, int unfold_level) {
rz_return_val_if_fail(typedb && type, NULL);
if (unfold_level < 0) { // any negative number means maximum unfolding
unfold_level = INT32_MAX;
}
HtPP *used_types = ht_pp_new0(); // use a hash table to keep track of unfolded types
if (!used_types) {
RZ_LOG_ERROR("Failed to create hashtable while pretty printing types")
return NULL;
}
char *pretty_type = type_as_pretty_string(typedb, type, identifier, used_types, opts, unfold_level, 0);
ht_pp_free(used_types);
return pretty_type;
}
/**
* \brief Returns the type C identifier
*
* In case of the compound types it returns the name of identifier
* For example, for "char **ptr" it will return "char",
* for "const int **arr[56][76]" it will return "int"
*
* \param type RzType type
*/
RZ_API RZ_BORROW const char *rz_type_identifier(RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, NULL);
switch (type->kind) {
case RZ_TYPE_KIND_IDENTIFIER: {
// Here it can be any of the RzBaseType
return type->identifier.name;
}
case RZ_TYPE_KIND_POINTER: {
return rz_type_identifier(type->pointer.type);
}
case RZ_TYPE_KIND_ARRAY: {
return rz_type_identifier(type->array.type);
break;
}
case RZ_TYPE_KIND_CALLABLE:
return type->callable->name;
}
return NULL;
}
/**
* \brief Creates an exact clone of the RzType
*
* \param type RzType pointer
*/
RZ_API RZ_OWN RzType *rz_type_clone(RZ_BORROW RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, NULL);
RzType *newtype = RZ_NEW0(RzType);
if (!newtype) {
return NULL;
}
switch (type->kind) {
case RZ_TYPE_KIND_IDENTIFIER:
newtype->kind = type->kind;
newtype->identifier.kind = type->identifier.kind;
newtype->identifier.is_const = type->identifier.is_const;
newtype->identifier.name = rz_str_dup(type->identifier.name);
break;
case RZ_TYPE_KIND_ARRAY:
newtype->kind = RZ_TYPE_KIND_ARRAY;
newtype->array.count = type->array.count;
newtype->array.type = rz_type_clone(type->array.type);
break;
case RZ_TYPE_KIND_POINTER:
newtype->kind = RZ_TYPE_KIND_POINTER;
newtype->pointer.is_const = type->pointer.is_const;
newtype->pointer.type = rz_type_clone(type->pointer.type);
break;
case RZ_TYPE_KIND_CALLABLE:
newtype->kind = RZ_TYPE_KIND_CALLABLE;
newtype->callable = rz_type_callable_clone(type->callable);
break;
}
return newtype;
}
/**
* \brief Checks if two types are identical
*
* \param type1 RzType pointer
* \param type2 RzType pointer
*/
RZ_API bool rz_types_equal(RZ_NONNULL const RzType *type1, RZ_NONNULL const RzType *type2) {
rz_return_val_if_fail(type1 && type2, false);
if (type1->kind != type2->kind) {
return false;
}
switch (type1->kind) {
case RZ_TYPE_KIND_IDENTIFIER:
return !strcmp(type1->identifier.name, type2->identifier.name);
case RZ_TYPE_KIND_POINTER:
rz_return_val_if_fail(type1->pointer.type && type2->pointer.type, false);
return rz_types_equal(type1->pointer.type, type2->pointer.type);
case RZ_TYPE_KIND_ARRAY:
if (type1->array.count != type2->array.count) {
return false;
}
return rz_types_equal(type1->array.type, type2->array.type);
case RZ_TYPE_KIND_CALLABLE:
rz_return_val_if_fail(type1->callable && type2->callable, false);
rz_return_val_if_fail(type1->callable->name && type2->callable->name, false);
return !strcmp(type1->callable->name, type2->callable->name);
default:
rz_warn_if_reached();
return false;
}
return false;
}
/**
* \brief Returns the RzBaseType for the chosen RzType
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API RZ_BORROW RzBaseType *rz_type_get_base_type(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
const char *identifier = rz_type_identifier(type);
if (!identifier) {
return NULL;
}
RzBaseType *btype = rz_type_db_get_base_type(typedb, identifier);
if (!btype) {
return NULL;
}
return btype;
}
/**
* \brief Frees the RzType
*
* Doesn't free the underlying RzBaseType, only the RzType wrapper.
* Same goes for the RzCallable. Both are stored in the corresponding
* hashtables and should not be touched until deleted explicitly.
*
* \param type RzType type
*/
RZ_API void rz_type_free(RZ_NULLABLE RzType *type) {
if (!type) {
return;
}
switch (type->kind) {
case RZ_TYPE_KIND_IDENTIFIER:
free(type->identifier.name);
break;
case RZ_TYPE_KIND_POINTER:
rz_type_free(type->pointer.type);
break;
case RZ_TYPE_KIND_ARRAY:
rz_type_free(type->array.type);
break;
case RZ_TYPE_KIND_CALLABLE:
break;
}
free(type);
}
/**
* \brief Edits the existing base type given the new C code
*
* Searches the base type in the types database given the \p name.
* If it exists - parses the \p typestr as the new C type. If there is
* any error during the parsing it restores the original type in the
* database.
*
* \param typedb Type Database instance
* \param name Name of the base type
* \param typestr C string of the new definition of the type
*/
RZ_API bool rz_type_db_edit_base_type(RzTypeDB *typedb, RZ_NONNULL const char *name, RZ_NONNULL const char *typestr) {
rz_return_val_if_fail(name && typestr, false);
RzBaseType *t = rz_type_db_get_compound_type(typedb, name);
if (!t) {
return false;
}
// Remove the original type first
// but do not free them
void *freefn = (void *)typedb->types->opt.freefn;
typedb->types->opt.freefn = types_ht_free_keep_val;
ht_pp_delete(typedb->types, t->name);
typedb->types->opt.freefn = freefn;
char *error_msg = NULL;
int result = rz_type_parse_string_stateless(typedb->parser, typestr, &error_msg);
if (result) {
if (error_msg) {
RZ_LOG_ERROR("%s\n", error_msg);
}
free(error_msg);
// There is an error during the parsing thus we restore the old type
// We insert the type back
ht_pp_insert(typedb->types, t->name, t);
return false;
}
// Free now unnecessary old base type
rz_type_base_type_free(t);
return true;
}
rizin-0.7.4/librz/type/typeclass.c 0000664 0001750 0001750 00000027634 14731035230 016507 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
/** \file typeclass.c
*
* Atomic types are split into the various type classes
*
* None < A default value and includes all types
* |
* + Num < Every numeric type
* |
* + Integral < Every integral (integer) type
* | |
* | - Signed Integral < Every signed integral type
* | - Unsigned Integral < Every unsigned integral type
* | - Address < Every integral type that used for memory addressing
* |
* + Floating < Every floating point type
*
*/
inline static bool typeclass_is_num(RzTypeTypeclass t) {
return t == RZ_TYPE_TYPECLASS_NUM || t == RZ_TYPE_TYPECLASS_INTEGRAL || t == RZ_TYPE_TYPECLASS_INTEGRAL_SIGNED || t == RZ_TYPE_TYPECLASS_INTEGRAL_UNSIGNED || t == RZ_TYPE_TYPECLASS_FLOATING || t == RZ_TYPE_TYPECLASS_ADDRESS;
}
inline static bool typeclass_is_integal(RzTypeTypeclass t) {
return t == RZ_TYPE_TYPECLASS_INTEGRAL || t == RZ_TYPE_TYPECLASS_INTEGRAL_SIGNED || t == RZ_TYPE_TYPECLASS_INTEGRAL_UNSIGNED || t == RZ_TYPE_TYPECLASS_ADDRESS;
}
/**
* \brief Returns the string representation of a typeclass
*
* \param typeclass A typeclass
*/
RZ_API RZ_BORROW const char *rz_type_typeclass_as_string(RzTypeTypeclass typeclass) {
switch (typeclass) {
case RZ_TYPE_TYPECLASS_NUM:
return "Num";
case RZ_TYPE_TYPECLASS_INTEGRAL:
return "Integral";
case RZ_TYPE_TYPECLASS_FLOATING:
return "Floating";
case RZ_TYPE_TYPECLASS_ADDRESS:
return "Address";
case RZ_TYPE_TYPECLASS_INTEGRAL_SIGNED:
return "Signed Integral";
case RZ_TYPE_TYPECLASS_INTEGRAL_UNSIGNED:
return "Unsigned Integral";
case RZ_TYPE_TYPECLASS_NONE:
return "None";
default:
rz_warn_if_reached();
}
return "None";
}
/**
* \brief Returns the typeclass from the string name of it
*
* \param typeclass A typeclass name
*/
RZ_API RzTypeTypeclass rz_type_typeclass_from_string(RZ_NONNULL const char *typeclass) {
rz_return_val_if_fail(typeclass && RZ_STR_ISNOTEMPTY(typeclass), RZ_TYPE_TYPECLASS_NONE);
if (!strcmp(typeclass, "Integral")) {
return RZ_TYPE_TYPECLASS_INTEGRAL;
} else if (!strcmp(typeclass, "Signed Integral")) {
return RZ_TYPE_TYPECLASS_INTEGRAL_SIGNED;
} else if (!strcmp(typeclass, "Unsigned Integral")) {
return RZ_TYPE_TYPECLASS_INTEGRAL_UNSIGNED;
} else if (!strcmp(typeclass, "Floating")) {
return RZ_TYPE_TYPECLASS_FLOATING;
} else if (!strcmp(typeclass, "Address")) {
return RZ_TYPE_TYPECLASS_ADDRESS;
} else if (!strcmp(typeclass, "Num")) {
return RZ_TYPE_TYPECLASS_NUM;
}
return RZ_TYPE_TYPECLASS_NONE;
}
inline static bool get_base_type_typeclass(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *type, RZ_NONNULL RzTypeTypeclass *typeclass) {
rz_return_val_if_fail(type && typeclass, false);
*typeclass = type->attrs & RZ_TYPE_ATTRIBUTE_TYPECLASS_MASK;
if (*typeclass < RZ_TYPE_TYPECLASS_INVALID) {
return true;
}
// If the type is typedef, we check the underlying type all the way down
if (*typeclass == 0 && type->kind == RZ_BASE_TYPE_KIND_TYPEDEF) {
// We do not treat pointers and arrays as the same typeclass
if (type->type->kind != RZ_TYPE_KIND_IDENTIFIER) {
return false;
}
const char *identifier = rz_type_identifier(type->type);
if (!identifier) {
return false;
}
RzBaseType *t = rz_type_db_get_base_type(typedb, identifier);
if (!t) {
return false;
}
return get_base_type_typeclass(typedb, t, typeclass);
}
return false;
}
inline static bool get_type_typeclass(const RzTypeDB *typedb, RZ_NONNULL const RzType *type, RzTypeTypeclass *typeclass) {
rz_return_val_if_fail(type && typeclass, false);
const char *identifier = rz_type_identifier(type);
if (!identifier) {
return false;
}
RzBaseType *t = rz_type_db_get_base_type(typedb, identifier);
if (!t) {
return false;
}
return get_base_type_typeclass(typedb, t, typeclass);
}
inline static bool check_base_type_typeclass(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *type, RzTypeTypeclass typeclass) {
rz_return_val_if_fail(type, false);
RzTypeTypeclass tclass;
if (!get_base_type_typeclass(typedb, type, &tclass)) {
return false;
}
return tclass == typeclass;
}
inline static bool check_type_typeclass(const RzTypeDB *typedb, RZ_NONNULL const RzType *type, RzTypeTypeclass typeclass) {
rz_return_val_if_fail(type, false);
RzTypeTypeclass tclass;
if (!get_type_typeclass(typedb, type, &tclass)) {
return false;
}
return tclass == typeclass;
}
/**
* \brief Gets the base type class
*
* \param typedb Type Database instance
* \param type RzBaseType type pointer
*/
RZ_API RzTypeTypeclass rz_base_type_typeclass(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *type) {
rz_return_val_if_fail(type, false);
RzTypeTypeclass tclass = RZ_TYPE_TYPECLASS_INVALID;
get_base_type_typeclass(typedb, type, &tclass);
return tclass;
}
/**
* \brief Gets the type class
*
* \param typedb Type Database instance
* \param type RzBaseType type pointer
*/
RZ_API RzTypeTypeclass rz_type_typeclass(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
RzTypeTypeclass tclass = RZ_TYPE_TYPECLASS_INVALID;
get_type_typeclass(typedb, type, &tclass);
return tclass;
}
/**
* \brief Checks if the RzBaseType is Num typeclass
*
* \param typedb Type Database instance
* \param type RzBaseType type pointer
*/
RZ_API bool rz_base_type_is_num(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *type) {
rz_return_val_if_fail(type, false);
RzTypeTypeclass tclass;
if (!get_base_type_typeclass(typedb, type, &tclass)) {
return false;
}
return typeclass_is_num(tclass);
}
/**
* \brief Checks if the RzType is Num typeclass
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_num(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
RzTypeTypeclass tclass;
if (!get_type_typeclass(typedb, type, &tclass)) {
return false;
}
return typeclass_is_num(tclass);
}
/**
* \brief Checks if the RzBaseType is Integral typeclass
*
* \param typedb Type Database instance
* \param type RzBaseType type pointer
*/
RZ_API bool rz_base_type_is_integral(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *type) {
rz_return_val_if_fail(type, false);
RzTypeTypeclass tclass;
if (!get_base_type_typeclass(typedb, type, &tclass)) {
return false;
}
return typeclass_is_integal(tclass);
}
/**
* \brief Checks if the RzType is Integral typeclass
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_integral(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
RzTypeTypeclass tclass;
if (!get_type_typeclass(typedb, type, &tclass)) {
return false;
}
return typeclass_is_integal(tclass);
}
/**
* \brief Checks if the RzBaseType is Floating typeclass
*
* \param typedb Type Database instance
* \param type RzBaseType type pointer
*/
RZ_API bool rz_base_type_is_floating(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *type) {
rz_return_val_if_fail(type, false);
return check_base_type_typeclass(typedb, type, RZ_TYPE_TYPECLASS_FLOATING);
}
/**
* \brief Checks if the RzType is Floating typeclass
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_floating(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
return check_type_typeclass(typedb, type, RZ_TYPE_TYPECLASS_FLOATING);
}
/**
* \brief Checks if the RzBaseType is Integral and Signed typeclass
*
* \param typedb Type Database instance
* \param type RzBaseType type pointer
*/
RZ_API bool rz_base_type_is_integral_signed(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *type) {
rz_return_val_if_fail(type, false);
return check_base_type_typeclass(typedb, type, RZ_TYPE_TYPECLASS_INTEGRAL_SIGNED);
}
/**
* \brief Checks if the RzType is Integral and Signed typeclass
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_integral_signed(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
return check_type_typeclass(typedb, type, RZ_TYPE_TYPECLASS_INTEGRAL_SIGNED);
}
/**
* \brief Checks if the RzBaseType is Integral and Unsigned typeclass
*
* \param typedb Type Database instance
* \param type RzBaseType type pointer
*/
RZ_API bool rz_base_type_is_integral_unsigned(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *type) {
rz_return_val_if_fail(type, false);
return check_base_type_typeclass(typedb, type, RZ_TYPE_TYPECLASS_INTEGRAL_UNSIGNED);
}
/**
* \brief Checks if the RzType is Integral and Unsigned typeclass
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_integral_unsigned(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
return check_type_typeclass(typedb, type, RZ_TYPE_TYPECLASS_INTEGRAL_UNSIGNED);
}
struct list_typeclass {
const RzTypeDB *typedb;
RzList /**/ *types;
RzTypeTypeclass typeclass;
};
static bool base_type_typeclass_collect_cb(void *user, const void *k, const void *v) {
struct list_typeclass *l = user;
RzBaseType *btype = (RzBaseType *)v;
RzTypeTypeclass typeclass;
if (!get_base_type_typeclass(l->typedb, btype, &typeclass)) {
return false;
}
if (l->typeclass == typeclass) {
rz_list_append(l->types, btype);
}
return true;
}
struct list_typeclass_size {
const RzTypeDB *typedb;
RzList /**/ *types;
RzTypeTypeclass typeclass;
size_t size;
};
static bool base_type_typeclass_sized_collect_cb(void *user, const void *k, const void *v) {
struct list_typeclass_size *l = user;
RzBaseType *btype = (RzBaseType *)v;
RzTypeTypeclass typeclass;
if (!get_base_type_typeclass(l->typedb, btype, &typeclass)) {
return false;
}
if (l->typeclass == typeclass && l->size == btype->size) {
rz_list_append(l->types, btype);
}
return true;
}
/**
* \brief Returns the list of all base types given the typeclass
*
* \param typedb Type Database instance
* \param typeclass typeclass (cannot be None)
*/
RZ_API RZ_OWN RzList /**/ *rz_type_typeclass_get_all(const RzTypeDB *typedb, RzTypeTypeclass typeclass) {
rz_return_val_if_fail(typedb && typeclass != RZ_TYPE_TYPECLASS_NONE, NULL);
rz_return_val_if_fail(typeclass < RZ_TYPE_TYPECLASS_INVALID, NULL);
RzList *types = rz_list_new();
struct list_typeclass lt = { typedb, types, typeclass };
ht_pp_foreach(typedb->types, base_type_typeclass_collect_cb, <);
return types;
}
/**
* \brief Returns the list of all base types given the typeclass and size
*
* \param typedb Type Database instance
* \param typeclass typeclass (cannot be None)
* \param size The bitsize of a type to select from
*/
RZ_API RZ_OWN RzList /**/ *rz_type_typeclass_get_all_sized(const RzTypeDB *typedb, RzTypeTypeclass typeclass, size_t size) {
rz_return_val_if_fail(typedb && typeclass != RZ_TYPE_TYPECLASS_NONE, NULL);
rz_return_val_if_fail(size && typeclass < RZ_TYPE_TYPECLASS_INVALID, NULL);
RzList *types = rz_list_new();
struct list_typeclass_size lt = { typedb, types, typeclass, size };
ht_pp_foreach(typedb->types, base_type_typeclass_sized_collect_cb, <);
return types;
}
/**
* \brief Returns the default base type given the typeclass and size
*
* \param typedb Type Database instance
* \param typeclass typeclass (cannot be None)
* \param size The bitsize of a type to select from
*/
RZ_API RZ_OWN RzBaseType *rz_type_typeclass_get_default_sized(const RzTypeDB *typedb, RzTypeTypeclass typeclass, size_t size) {
rz_return_val_if_fail(typedb && typeclass != RZ_TYPE_TYPECLASS_NONE, NULL);
rz_return_val_if_fail(size && typeclass < RZ_TYPE_TYPECLASS_INVALID, NULL);
RzList *l = rz_type_typeclass_get_all_sized(typedb, typeclass, size);
if (!l || rz_list_empty(l)) {
return NULL;
}
RzBaseType *ret = rz_list_pop(l);
rz_list_free(l);
return ret;
}
rizin-0.7.4/librz/type/serialize_functions.c 0000664 0001750 0001750 00000021456 14731035230 020553 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#include
/**
* Parse a type or take it from the cache if it has been parsed before already.
* This cache is really only relevant because types are stored in the sdb as their C expression,
* making them extremely slow to load. If they will be e.g. json in the future, this cache can be removed.
*
* \param newly_added list of strings where str is appended if it has been added to the cache in this pass
*/
static RzType *parse_type_string_cached(RzTypeParser *parser, HtPP *cache, const char *str, char **error_msg, RZ_OUT RzList /**/ *newly_added) {
rz_return_val_if_fail(str, NULL);
RzType *r = ht_pp_find(cache, str, NULL);
if (r) {
*error_msg = NULL;
return rz_type_clone(r);
}
r = rz_type_parse_string_single(parser, str, error_msg);
if (r) {
char *reminder = strdup(str);
if (reminder) {
ht_pp_insert(cache, str, r);
rz_list_push(newly_added, reminder);
}
}
return r;
}
static void type_string_cache_rollback(HtPP *cache, RzList /**/ *newly_added) {
RzListIter *it;
char *s;
rz_list_foreach (newly_added, it, s) {
ht_pp_delete(cache, s);
}
}
static RzCallable *get_callable_type(RzTypeDB *typedb, Sdb *sdb, const char *name, HtPP *type_str_cache) {
rz_return_val_if_fail(typedb && sdb && RZ_STR_ISNOTEMPTY(name), NULL);
RzList *cache_newly_added = rz_list_newf(free);
if (!cache_newly_added) {
return NULL;
}
RzCallable *callable = rz_type_func_new(typedb, name, NULL);
if (!callable) {
rz_list_free(cache_newly_added);
return NULL;
}
RzStrBuf key;
size_t arguments = sdb_num_get(sdb, rz_strbuf_initf(&key, "func.%s.args", name), 0);
if (arguments > 0 && !rz_pvector_reserve(callable->args, arguments)) {
goto error;
}
int i;
for (i = 0; i < arguments; i++) {
char *values = sdb_get(sdb, rz_strbuf_setf(&key, "func.%s.arg.%d", name, i), NULL);
if (!values) {
goto error;
}
char arg_name[32];
char *argument_name;
char *argument_type = sdb_anext(values, &argument_name);
if (!argument_name) {
// Autoname unnamed arguments
argument_name = rz_strf(arg_name, "arg%d", i);
}
char *error_msg = NULL;
RzType *ttype = parse_type_string_cached(typedb->parser, type_str_cache, argument_type, &error_msg, cache_newly_added);
if (!ttype || error_msg) {
eprintf("error parsing \"%s\" func arg type \"%s\": %s\n", name, argument_type, error_msg);
free(values);
goto error;
}
RzCallableArg *arg = rz_type_callable_arg_new(typedb, argument_name, ttype);
if (!arg) {
free(values);
rz_type_free(ttype);
goto error;
}
free(values);
void *element = rz_pvector_push(callable->args, arg); // returns null if no space available
if (!element) {
rz_type_callable_arg_free(arg);
goto error;
}
}
const char *rettype = sdb_const_get(sdb, rz_strbuf_setf(&key, "func.%s.ret", name), 0);
if (!rettype) {
// best we can do for a broken database
rettype = "void";
}
char *error_msg = NULL;
RzType *ttype = parse_type_string_cached(typedb->parser, type_str_cache, rettype, &error_msg, cache_newly_added);
if (!ttype || error_msg) {
eprintf("error parsing \"%s\" func return type \"%s\": %s \n", name, rettype, error_msg);
free(error_msg);
goto error;
}
callable->ret = ttype;
// Optional "noreturn" attribute
callable->noret = sdb_bool_get(sdb, rz_strbuf_setf(&key, "func.%s.noreturn", name), 0);
rz_strbuf_fini(&key);
rz_list_free(cache_newly_added);
return callable;
error:
// remove any types from the cache that will be freed by the callable_free below
type_string_cache_rollback(type_str_cache, cache_newly_added);
rz_list_free(cache_newly_added);
rz_type_callable_free(callable);
rz_strbuf_fini(&key);
return NULL;
}
static bool filter_func(void *user, const char *k, const char *v) {
return !strcmp(v, "func");
}
static bool sdb_load_callables(RzTypeDB *typedb, Sdb *sdb) {
rz_return_val_if_fail(typedb && sdb, false);
HtPP *type_str_cache = ht_pp_new0(); // cache from a known C type extr to its RzType representation for skipping the parser if possible
if (!type_str_cache) {
return false;
}
RzCallable *callable;
SdbKv *kv;
SdbListIter *iter;
SdbList *l = sdb_foreach_list_filter(sdb, filter_func, false);
ls_foreach (l, iter, kv) {
// eprintf("loading function: \"%s\"\n", sdbkv_key(kv));
callable = get_callable_type(typedb, sdb, sdbkv_key(kv), type_str_cache);
if (callable) {
ht_pp_update(typedb->callables, callable->name, callable);
RZ_LOG_DEBUG("inserting the \"%s\" callable type\n", callable->name);
}
}
ht_pp_free(type_str_cache);
ls_free(l);
return true;
}
static bool sdb_load_by_path(RZ_NONNULL RzTypeDB *typedb, RZ_NONNULL const char *path) {
rz_return_val_if_fail(typedb && path, false);
if (RZ_STR_ISEMPTY(path)) {
return false;
}
Sdb *db = sdb_new(0, path, 0);
bool result = sdb_load_callables(typedb, db);
sdb_close(db);
sdb_free(db);
return result;
}
static bool sdb_load_from_string(RZ_NONNULL RzTypeDB *typedb, RZ_NONNULL const char *string) {
rz_return_val_if_fail(typedb && string, false);
if (RZ_STR_ISEMPTY(string)) {
return false;
}
Sdb *db = sdb_new0();
sdb_query_lines(db, string);
bool result = sdb_load_callables(typedb, db);
sdb_close(db);
sdb_free(db);
return result;
}
static void save_callable(const RzTypeDB *typedb, Sdb *sdb, const RzCallable *callable) {
rz_return_if_fail(typedb && sdb && callable && callable->name);
/*
C:
type name (type param1, type param2, type paramN);
Sdb:
name=func
func.name.args=N
func.name.arg.0=type,param1
func.name.arg.1=type,param2
func.name.arg.N=type,paramN
func.name.ret=type
*/
const char *cname = callable->name;
// name=func
sdb_set(sdb, cname, "func", 0);
// func.name.args=N
char *key = rz_str_newf("func.%s.args", cname);
sdb_num_set(sdb, key, rz_pvector_len(callable->args), 0);
free(key);
RzStrBuf param_key;
RzStrBuf param_val;
rz_strbuf_init(¶m_key);
rz_strbuf_init(¶m_val);
size_t i = 0;
void **it;
rz_pvector_foreach (callable->args, it) {
RzCallableArg *arg = *it;
// func.name.arg.N=type,paramN
char *arg_name = rz_str_sanitize_sdb_key(arg->name);
char *arg_type = rz_type_as_string(typedb, arg->type);
sdb_set(sdb,
rz_strbuf_setf(¶m_key, "func.%s.arg.%zu", cname, i),
rz_strbuf_setf(¶m_val, "%s,%s", arg_type, arg_name), 0ULL);
free(arg_name);
free(arg_type);
}
rz_strbuf_fini(¶m_key);
rz_strbuf_fini(¶m_val);
// func.name.ret=type
if (callable->ret) {
key = rz_str_newf("func.%s.ret", cname);
char *ret_type = rz_type_as_string(typedb, callable->ret);
sdb_set_owned(sdb, key, ret_type, 0);
free(key);
}
// Optional "noreturn" attribute
if (callable->noret) {
char *noreturn_key = rz_str_newf("func.%s.noreturn", cname);
sdb_bool_set(sdb, noreturn_key, true, 0);
free(noreturn_key);
}
}
struct typedb_sdb {
const RzTypeDB *typedb;
Sdb *sdb;
};
static bool export_callable_cb(void *user, const void *k, const void *v) {
struct typedb_sdb *s = user;
RzCallable *callable = (RzCallable *)v;
save_callable(s->typedb, s->sdb, callable);
return true;
}
static bool callable_export_sdb(RZ_NONNULL Sdb *db, RZ_NONNULL const RzTypeDB *typedb) {
struct typedb_sdb tdb = { typedb, db };
ht_pp_foreach(typedb->callables, export_callable_cb, &tdb);
return true;
}
/**
* \brief Loads the callable types from compiled SDB specified by path
*
* \param typedb RzTypeDB instance
* \param path A path to the compiled SDB containing serialized types
*/
RZ_API bool rz_type_db_load_callables_sdb(RzTypeDB *typedb, RZ_NONNULL const char *path) {
rz_return_val_if_fail(typedb && path, false);
if (!rz_file_exists(path)) {
return false;
}
return sdb_load_by_path(typedb, path);
}
/**
* \brief Loads the callable types from SDB KV string
*
* \param typedb RzTypeDB instance
* \param str A string in Key-Value format as for non-compiled SDB
*/
RZ_API bool rz_type_db_load_callables_sdb_str(RzTypeDB *typedb, RZ_NONNULL const char *str) {
rz_return_val_if_fail(typedb && str, false);
if (RZ_STR_ISEMPTY(str)) {
return false;
}
return sdb_load_from_string(typedb, str);
}
/**
* \brief Saves the callable types into SDB
*
* \param db A SDB database object
* \param typedb RzTypeDB instance
*/
RZ_API void rz_serialize_callables_save(RZ_NONNULL Sdb *db, RZ_NONNULL RzTypeDB *typedb) {
rz_return_if_fail(db && typedb);
callable_export_sdb(db, typedb);
}
/**
* \brief Loads the callable types from SDB
*
* \param db A SDB database object
* \param typedb RzTypeDB instance
* \param res A structure where the result is stored
*/
RZ_API bool rz_serialize_callables_load(RZ_NONNULL Sdb *db, RZ_NONNULL RzTypeDB *typedb, RZ_NULLABLE RzSerializeResultInfo *res) {
rz_return_val_if_fail(db && typedb, false);
return sdb_load_callables(typedb, db);
}
rizin-0.7.4/librz/type/serialize_types.c 0000664 0001750 0001750 00000044441 14731035230 017706 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#include
typedef struct {
RzBaseType *type;
char *format;
} TypeFormatPair;
inline static RzTypeTypeclass get_base_type_typeclass(RZ_NONNULL const RzBaseType *type) {
rz_return_val_if_fail(type, RZ_TYPE_TYPECLASS_INVALID);
return type->attrs & RZ_TYPE_ATTRIBUTE_TYPECLASS_MASK;
}
inline static void set_base_type_typeclass(RZ_NONNULL RzBaseType *type, RzTypeTypeclass typeclass) {
rz_return_if_fail(type && typeclass < RZ_TYPE_TYPECLASS_INVALID);
type->attrs = typeclass;
}
static char *get_type_data(Sdb *sdb, const char *type, const char *sname) {
rz_return_val_if_fail(sdb && RZ_STR_ISNOTEMPTY(type) && RZ_STR_ISNOTEMPTY(sname), NULL);
char *key = rz_str_newf("%s.%s", type, sname);
if (!key) {
return NULL;
}
char *members = sdb_get(sdb, key, NULL);
free(key);
return members;
}
static TypeFormatPair *get_enum_type(Sdb *sdb, const char *sname) {
rz_return_val_if_fail(sdb && RZ_STR_ISNOTEMPTY(sname), NULL);
RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_ENUM);
if (!base_type) {
return NULL;
}
char *members = get_type_data(sdb, "enum", sname);
if (!members) {
goto error;
}
base_type->name = strdup(sname);
RzVector *cases = &base_type->enum_data.cases;
if (!rz_vector_reserve(cases, (size_t)sdb_alen(members))) {
goto error;
}
char *cur;
sdb_aforeach(cur, members) {
char *val_key = rz_str_newf("enum.%s.%s", sname, cur);
if (!val_key) {
goto error;
}
const char *value = sdb_const_get(sdb, val_key, NULL);
free(val_key);
if (!value) { // if nothing is found, ret NULL
goto error;
}
RzTypeEnumCase cas = { .name = strdup(cur), .val = strtol(value, NULL, 16) };
void *element = rz_vector_push(cases, &cas); // returns null if no space available
if (!element) {
goto error;
}
sdb_aforeach_next(cur);
}
free(members);
RzStrBuf key;
char *format = sdb_get(sdb, rz_strbuf_initf(&key, "type.%s", sname), 0);
rz_strbuf_fini(&key);
TypeFormatPair *tpair = RZ_NEW0(TypeFormatPair);
tpair->type = base_type;
tpair->format = format;
return tpair;
error:
free(members);
rz_type_base_type_free(base_type);
return NULL;
}
static TypeFormatPair *get_struct_type(RzTypeDB *typedb, Sdb *sdb, const char *sname) {
rz_return_val_if_fail(typedb && sdb && RZ_STR_ISNOTEMPTY(sname), NULL);
RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_STRUCT);
if (!base_type) {
return NULL;
}
base_type->name = strdup(sname);
char *sdb_members = get_type_data(sdb, "struct", sname);
if (sdb_members) {
RzVector *members = &base_type->struct_data.members;
if (!rz_vector_reserve(members, (size_t)sdb_alen(sdb_members))) {
goto error;
}
char *cur;
sdb_aforeach(cur, sdb_members) {
char *type_key = rz_str_newf("struct.%s.%s", sname, cur);
if (!type_key) {
goto error;
}
char *values = sdb_get(sdb, type_key, NULL);
free(type_key);
if (!values) {
goto error;
}
char *offset = NULL;
char *type = sdb_anext(values, &offset);
if (!offset) { // offset is missing, malformed state
free(values);
goto error;
}
// Parse type as a C string
char *error_msg = NULL;
RzType *ttype = rz_type_parse_string_single(typedb->parser, type, &error_msg);
if (!ttype || error_msg) {
free(error_msg);
free(values);
goto error;
}
RzTypeStructMember memb = {
.name = strdup(cur),
.type = ttype,
.offset = strtol(offset, NULL, 10)
};
free(values);
void *element = rz_vector_push(members, &memb); // returns null if no space available
if (!element) {
goto error;
}
sdb_aforeach_next(cur);
}
free(sdb_members);
}
RzStrBuf key;
const char *format = sdb_get(sdb, rz_strbuf_initf(&key, "type.%s", sname), 0);
rz_strbuf_fini(&key);
TypeFormatPair *tpair = RZ_NEW0(TypeFormatPair);
tpair->type = base_type;
tpair->format = format ? strdup(format) : NULL;
return tpair;
error:
rz_type_base_type_free(base_type);
free(sdb_members);
return NULL;
}
static TypeFormatPair *get_union_type(RzTypeDB *typedb, Sdb *sdb, const char *sname) {
rz_return_val_if_fail(typedb && sdb && RZ_STR_ISNOTEMPTY(sname), NULL);
RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_UNION);
if (!base_type) {
return NULL;
}
base_type->name = strdup(sname);
char *sdb_members = get_type_data(sdb, "union", sname);
if (sdb_members) {
RzVector *members = &base_type->union_data.members;
if (!rz_vector_reserve(members, (size_t)sdb_alen(sdb_members))) {
goto error;
}
char *cur;
sdb_aforeach(cur, sdb_members) {
char *type_key = rz_str_newf("union.%s.%s", sname, cur);
if (!type_key) {
goto error;
}
char *values = sdb_get(sdb, type_key, NULL);
free(type_key);
if (!values) {
goto error;
}
char *value = sdb_anext(values, NULL);
char *error_msg = NULL;
RzType *ttype = rz_type_parse_string_single(typedb->parser, value, &error_msg);
if (!ttype || error_msg) {
free(values);
goto error;
}
RzTypeUnionMember memb = {
.name = strdup(cur),
.type = ttype
};
free(values);
void *element = rz_vector_push(members, &memb); // returns null if no space available
if (!element) {
goto error;
}
sdb_aforeach_next(cur);
}
free(sdb_members);
}
RzStrBuf key;
const char *format = sdb_get(sdb, rz_strbuf_initf(&key, "type.%s", sname), 0);
rz_strbuf_fini(&key);
TypeFormatPair *tpair = RZ_NEW0(TypeFormatPair);
tpair->type = base_type;
tpair->format = format ? strdup(format) : NULL;
return tpair;
error:
rz_type_base_type_free(base_type);
free(sdb_members);
return NULL;
}
static TypeFormatPair *get_typedef_type(RzTypeDB *typedb, Sdb *sdb, const char *sname) {
rz_return_val_if_fail(typedb && sdb && RZ_STR_ISNOTEMPTY(sname), NULL);
RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_TYPEDEF);
if (!base_type) {
return NULL;
}
base_type->name = strdup(sname);
char *type = get_type_data(sdb, "typedef", sname);
char *error_msg = NULL;
RzType *ttype = rz_type_parse_string_single(typedb->parser, type, &error_msg);
if (!ttype || error_msg) {
goto error;
}
free(type);
base_type->type = ttype;
if (!base_type->type) {
goto error;
}
RzStrBuf key;
char *format = sdb_get(sdb, rz_strbuf_initf(&key, "type.%s", sname), 0);
rz_strbuf_fini(&key);
TypeFormatPair *tpair = RZ_NEW0(TypeFormatPair);
tpair->type = base_type;
tpair->format = format;
return tpair;
error:
free(type);
rz_type_base_type_free(base_type);
return NULL;
}
static TypeFormatPair *get_atomic_type(RzTypeDB *typedb, Sdb *sdb, const char *sname) {
rz_return_val_if_fail(typedb && sdb && RZ_STR_ISNOTEMPTY(sname), NULL);
RzBaseType *base_type = rz_type_base_type_new(RZ_BASE_TYPE_KIND_ATOMIC);
if (!base_type) {
return NULL;
}
RzType *ttype = RZ_NEW0(RzType);
if (!ttype) {
goto error;
}
ttype->kind = RZ_TYPE_KIND_IDENTIFIER;
ttype->identifier.name = strdup(sname);
ttype->identifier.is_const = false; // We don't preload const types by default
ttype->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
base_type->type = ttype;
base_type->name = strdup(sname);
RzStrBuf key;
base_type->size = sdb_num_get(sdb, rz_strbuf_initf(&key, "type.%s.size", sname), 0);
RzTypeTypeclass typeclass = RZ_TYPE_TYPECLASS_NONE;
const char *tclass = sdb_const_get(sdb, rz_strbuf_setf(&key, "type.%s.typeclass", sname), 0);
if (tclass) {
typeclass = rz_type_typeclass_from_string(tclass);
}
set_base_type_typeclass(base_type, typeclass);
const char *format = sdb_const_get(sdb, rz_strbuf_setf(&key, "type.%s", sname), 0);
rz_strbuf_fini(&key);
TypeFormatPair *tpair = RZ_NEW0(TypeFormatPair);
tpair->type = base_type;
tpair->format = format ? strdup(format) : NULL;
return tpair;
error:
rz_type_base_type_free(base_type);
return NULL;
}
bool sdb_load_base_types(RzTypeDB *typedb, Sdb *sdb) {
rz_return_val_if_fail(typedb && sdb, false);
SdbKv *kv;
SdbListIter *iter;
SdbList *l = sdb_foreach_list(sdb, false);
ls_foreach (l, iter, kv) {
TypeFormatPair *tpair = NULL;
if (!strcmp(sdbkv_value(kv), "struct")) {
tpair = get_struct_type(typedb, sdb, sdbkv_key(kv));
} else if (!strcmp(sdbkv_value(kv), "enum")) {
tpair = get_enum_type(sdb, sdbkv_key(kv));
} else if (!strcmp(sdbkv_value(kv), "union")) {
tpair = get_union_type(typedb, sdb, sdbkv_key(kv));
} else if (!strcmp(sdbkv_value(kv), "typedef")) {
tpair = get_typedef_type(typedb, sdb, sdbkv_key(kv));
} else if (!strcmp(sdbkv_value(kv), "type")) {
tpair = get_atomic_type(typedb, sdb, sdbkv_key(kv));
}
if (tpair && tpair->type) {
ht_pp_update(typedb->types, tpair->type->name, tpair->type);
// If the SDB provided the preferred type format then we store it
char *format = tpair->format ? tpair->format : NULL;
// Format is not always defined, e.g. for types like "void" or anonymous types
if (format) {
ht_pp_update(typedb->formats, tpair->type->name, format);
RZ_LOG_DEBUG("inserting the \"%s\" type & format: \"%s\"\n", tpair->type->name, format);
} else {
ht_pp_delete(typedb->formats, tpair->type->name);
}
} else if (tpair) {
free(tpair->format);
}
free(tpair);
}
ls_free(l);
return true;
}
static void save_struct(const RzTypeDB *typedb, Sdb *sdb, const RzBaseType *type) {
rz_return_if_fail(typedb && sdb && type && type->name && type->kind == RZ_BASE_TYPE_KIND_STRUCT);
const char *kind = "struct";
/*
C:
struct name {type param1; type param2; type paramN;};
Sdb:
name=struct
struct.name=param1,param2,paramN
struct.name.param1=type,0,0
struct.name.param2=type,4,0
struct.name.paramN=type,8,0
*/
char *sname = type->name;
// name=struct
sdb_set(sdb, sname, kind, 0);
RzStrBuf arglist;
RzStrBuf param_key;
RzStrBuf param_val;
rz_strbuf_init(&arglist);
rz_strbuf_init(¶m_key);
rz_strbuf_init(¶m_val);
int i = 0;
RzTypeStructMember *member;
rz_vector_foreach(&type->struct_data.members, member) {
// struct.name.param=type,offset,argsize
char *member_sname = rz_str_sanitize_sdb_key(member->name);
char *member_type = rz_type_as_string(typedb, member->type);
sdb_set(sdb,
rz_strbuf_setf(¶m_key, "%s.%s.%s", kind, sname, member_sname),
rz_strbuf_setf(¶m_val, "%s,%zu,%u", member_type, member->offset, 0), 0ULL);
free(member_type);
free(member_sname);
rz_strbuf_appendf(&arglist, (i++ == 0) ? "%s" : ",%s", member->name);
}
// struct.name=param1,param2,paramN
char *key = rz_str_newf("%s.%s", kind, sname);
sdb_set(sdb, key, rz_strbuf_get(&arglist), 0);
free(key);
rz_strbuf_fini(&arglist);
rz_strbuf_fini(¶m_key);
rz_strbuf_fini(¶m_val);
}
static void save_union(const RzTypeDB *typedb, Sdb *sdb, const RzBaseType *type) {
rz_return_if_fail(typedb && sdb && type && type->name && type->kind == RZ_BASE_TYPE_KIND_UNION);
const char *kind = "union";
/*
C:
union name {type param1; type param2; type paramN;};
Sdb:
name=union
union.name=param1,param2,paramN
union.name.param1=type,0,0
union.name.param2=type,0,0
union.name.paramN=type,0,0
*/
char *sname = type->name;
// name=union
sdb_set(sdb, sname, kind, 0);
RzStrBuf arglist;
RzStrBuf param_key;
RzStrBuf param_val;
rz_strbuf_init(&arglist);
rz_strbuf_init(¶m_key);
rz_strbuf_init(¶m_val);
int i = 0;
RzTypeUnionMember *member;
rz_vector_foreach(&type->union_data.members, member) {
// union.name.arg1=type,offset,argsize
char *member_sname = rz_str_sanitize_sdb_key(member->name);
char *member_type = rz_type_as_string(typedb, member->type);
sdb_set(sdb,
rz_strbuf_setf(¶m_key, "%s.%s.%s", kind, sname, member_sname),
rz_strbuf_setf(¶m_val, "%s,%zu,%u", member_type, member->offset, 0), 0ULL);
free(member_type);
free(member_sname);
rz_strbuf_appendf(&arglist, (i++ == 0) ? "%s" : ",%s", member->name);
}
// union.name=arg1,arg2,argN
char *key = rz_str_newf("%s.%s", kind, sname);
sdb_set(sdb, key, rz_strbuf_get(&arglist), 0);
free(key);
rz_strbuf_fini(&arglist);
rz_strbuf_fini(¶m_key);
rz_strbuf_fini(¶m_val);
}
static void save_enum(const RzTypeDB *typedb, Sdb *sdb, const RzBaseType *type) {
rz_return_if_fail(typedb && sdb && type && type->name && type->kind == RZ_BASE_TYPE_KIND_ENUM);
/*
C:
enum name {case1 = 1, case2 = 2, caseN = 3};
Sdb:
name=enum
enum.name=arg1,arg2,argN
enum.MyEnum.0x1=arg1
enum.MyEnum.0x3=arg2
enum.MyEnum.0x63=argN
enum.MyEnum.arg1=0x1
enum.MyEnum.arg2=0x63
enum.MyEnum.argN=0x3
*/
char *sname = type->name;
sdb_set(sdb, sname, "enum", 0);
RzStrBuf arglist;
RzStrBuf param_key;
RzStrBuf param_val;
rz_strbuf_init(&arglist);
rz_strbuf_init(¶m_key);
rz_strbuf_init(¶m_val);
int i = 0;
RzTypeEnumCase *cas;
rz_vector_foreach(&type->enum_data.cases, cas) {
// enum.name.arg1=type,offset,???
char *case_sname = rz_str_sanitize_sdb_key(cas->name);
sdb_set(sdb,
rz_strbuf_setf(¶m_key, "enum.%s.%s", sname, case_sname),
rz_strbuf_setf(¶m_val, "0x%" PFMT64x "", cas->val), 0);
sdb_set(sdb,
rz_strbuf_setf(¶m_key, "enum.%s.0x%" PFMT64x "", sname, cas->val),
case_sname, 0);
free(case_sname);
rz_strbuf_appendf(&arglist, (i++ == 0) ? "%s" : ",%s", cas->name);
}
// enum.name=arg1,arg2,argN
char *key = rz_str_newf("enum.%s", sname);
sdb_set(sdb, key, rz_strbuf_get(&arglist), 0);
free(key);
rz_strbuf_fini(&arglist);
rz_strbuf_fini(¶m_key);
rz_strbuf_fini(¶m_val);
}
static void save_atomic_type(const RzTypeDB *typedb, Sdb *sdb, const RzBaseType *type) {
rz_return_if_fail(typedb && sdb && type && type->name && type->kind == RZ_BASE_TYPE_KIND_ATOMIC);
/*
C: (cannot define a custom atomic type)
Sdb:
char=type
type.char=c
type.char.size=8
type.char.typeclass=Signed Integral
*/
char *sname = type->name;
sdb_set(sdb, sname, "type", 0);
RzStrBuf key;
RzStrBuf val;
rz_strbuf_init(&key);
rz_strbuf_init(&val);
sdb_set(sdb,
rz_strbuf_setf(&key, "type.%s.size", sname),
rz_strbuf_setf(&val, "%" PFMT64u "", type->size), 0);
sdb_set(sdb,
rz_strbuf_setf(&key, "type.%s.typeclass", sname),
rz_type_typeclass_as_string(get_base_type_typeclass(type)), 0);
const char *typefmt = rz_type_db_format_get(typedb, sname);
sdb_set(sdb,
rz_strbuf_setf(&key, "type.%s", sname),
typefmt, 0);
rz_strbuf_fini(&key);
rz_strbuf_fini(&val);
}
static void save_typedef(const RzTypeDB *typedb, Sdb *sdb, const RzBaseType *type) {
rz_return_if_fail(typedb && sdb && type && type->name && type->kind == RZ_BASE_TYPE_KIND_TYPEDEF);
/*
C:
typedef char byte;
Sdb:
byte=typedef
typedef.byte=char
*/
char *sname = type->name;
sdb_set(sdb, sname, "typedef", 0);
RzStrBuf key;
RzStrBuf val;
rz_strbuf_init(&key);
rz_strbuf_init(&val);
char *ttype = rz_type_as_string(typedb, type->type);
sdb_set(sdb,
rz_strbuf_setf(&key, "typedef.%s", sname),
rz_strbuf_setf(&val, "%s", ttype), 0);
free(ttype);
rz_strbuf_fini(&key);
rz_strbuf_fini(&val);
}
void sdb_save_base_type(const RzTypeDB *typedb, RZ_NONNULL Sdb *sdb, const RzBaseType *type) {
rz_return_if_fail(typedb && sdb && type && type->name);
switch (type->kind) {
case RZ_BASE_TYPE_KIND_STRUCT:
RZ_LOG_DEBUG("Serializing struct \"%s\"\n", type->name);
save_struct(typedb, sdb, type);
break;
case RZ_BASE_TYPE_KIND_ENUM:
RZ_LOG_DEBUG("Serializing enum \"%s\"\n", type->name);
save_enum(typedb, sdb, type);
break;
case RZ_BASE_TYPE_KIND_UNION:
RZ_LOG_DEBUG("Serializing union \"%s\"\n", type->name);
save_union(typedb, sdb, type);
break;
case RZ_BASE_TYPE_KIND_TYPEDEF:
RZ_LOG_DEBUG("Serializing type alias \"%s\"\n", type->name);
save_typedef(typedb, sdb, type);
break;
case RZ_BASE_TYPE_KIND_ATOMIC:
RZ_LOG_DEBUG("Serializing atomic type \"%s\"\n", type->name);
save_atomic_type(typedb, sdb, type);
break;
default:
break;
}
}
RZ_IPI bool types_load_sdb(RZ_NONNULL Sdb *db, RZ_NONNULL RzTypeDB *typedb) {
return sdb_load_base_types(typedb, db);
}
struct typedb_sdb {
const RzTypeDB *typedb;
Sdb *sdb;
};
static bool export_base_type_cb(void *user, const void *k, const void *v) {
struct typedb_sdb *s = user;
RzBaseType *btype = (RzBaseType *)v;
sdb_save_base_type(s->typedb, s->sdb, btype);
return true;
}
static bool types_export_sdb(RZ_NONNULL Sdb *db, RZ_NONNULL const RzTypeDB *typedb) {
struct typedb_sdb tdb = { typedb, db };
ht_pp_foreach(typedb->types, export_base_type_cb, &tdb);
return true;
}
static bool sdb_load_by_path(RZ_NONNULL RzTypeDB *typedb, RZ_NONNULL const char *path) {
rz_return_val_if_fail(typedb && path, false);
if (RZ_STR_ISEMPTY(path)) {
return false;
}
Sdb *db = sdb_new(0, path, 0);
bool result = types_load_sdb(db, typedb);
sdb_close(db);
sdb_free(db);
return result;
}
static bool sdb_load_from_string(RZ_NONNULL RzTypeDB *typedb, RZ_NONNULL const char *string) {
rz_return_val_if_fail(typedb && string, false);
if (RZ_STR_ISEMPTY(string)) {
return false;
}
Sdb *db = sdb_new0();
sdb_query_lines(db, string);
bool result = types_load_sdb(db, typedb);
sdb_close(db);
sdb_free(db);
return result;
}
/**
* \brief Loads the types from compiled SDB specified by path
*
* \param typedb RzTypeDB instance
* \param path A path to the compiled SDB containing serialized types
*/
RZ_API bool rz_type_db_load_sdb(RzTypeDB *typedb, RZ_NONNULL const char *path) {
rz_return_val_if_fail(typedb && path, false);
if (!rz_file_exists(path)) {
return false;
}
return sdb_load_by_path(typedb, path);
}
/**
* \brief Loads the types from SDB KV string
*
* \param typedb RzTypeDB instance
* \param str A string in Key-Value format as for non-compiled SDB
*/
RZ_API bool rz_type_db_load_sdb_str(RzTypeDB *typedb, RZ_NONNULL const char *str) {
rz_return_val_if_fail(typedb && str, false);
if (RZ_STR_ISEMPTY(str)) {
return false;
}
return sdb_load_from_string(typedb, str);
}
/**
* \brief Saves the types into SDB
*
* \param db A SDB database object
* \param typedb RzTypeDB instance
*/
RZ_API void rz_serialize_types_save(RZ_NONNULL Sdb *db, RZ_NONNULL const RzTypeDB *typedb) {
rz_return_if_fail(db && typedb);
types_export_sdb(db, typedb);
}
/**
* \brief Loads the types from SDB
*
* \param db A SDB database object
* \param typedb RzTypeDB instance
* \param res A structure where the result is stored
*/
RZ_API bool rz_serialize_types_load(RZ_NONNULL Sdb *db, RZ_NONNULL RzTypeDB *typedb, RZ_NULLABLE RzSerializeResultInfo *res) {
rz_return_val_if_fail(db && typedb, false);
return types_load_sdb(db, typedb);
}
rizin-0.7.4/librz/type/helpers.c 0000664 0001750 0001750 00000042474 14731035230 016141 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
/**
* \brief Creates a new RzType indentifier from the given RzBaseType
*
* \param typedb Type Database instance
* \param btype RzBaseType pointer
* \param is_const Set the identifier to "const" if true
*/
RZ_API RZ_OWN RzType *rz_type_identifier_of_base_type(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *btype, bool is_const) {
rz_return_val_if_fail(typedb && btype, NULL);
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
type->kind = RZ_TYPE_KIND_IDENTIFIER;
type->identifier.name = strdup(btype->name);
type->identifier.is_const = is_const;
switch (btype->kind) {
case RZ_BASE_TYPE_KIND_STRUCT:
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_STRUCT;
break;
case RZ_BASE_TYPE_KIND_UNION:
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNION;
break;
case RZ_BASE_TYPE_KIND_ENUM:
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_ENUM;
break;
default:
type->identifier.kind = RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED;
break;
}
return type;
}
/**
* \brief Creates a new RzType indentifier from the given RzBaseType name
*
* \param typedb Type Database instance
* \param name RzBaseType name
*/
RZ_API RZ_OWN RzType *rz_type_identifier_of_base_type_str(const RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, NULL);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return NULL;
}
return rz_type_identifier_of_base_type(typedb, btype, false);
}
/**
* \brief Creates a new pointer RzType from the given RzBaseType
*
* \param typedb Type Database instance
* \param btype RzBaseType pointer
* \param is_const Set the pointer to "const" if true
*/
RZ_API RZ_OWN RzType *rz_type_pointer_of_base_type(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *btype, bool is_const) {
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
RzType *t = rz_type_identifier_of_base_type(typedb, btype, false);
if (!t) {
rz_type_free(type);
return NULL;
}
type->kind = RZ_TYPE_KIND_POINTER;
type->pointer.type = t;
type->pointer.is_const = is_const;
return type;
}
/**
* \brief Creates a new pointer RzType from the given RzBaseType name
*
* \param typedb Type Database instance
* \param name RzBaseType name
* \param is_const Set the pointer to "const" if true
*/
RZ_API RZ_OWN RzType *rz_type_pointer_of_base_type_str(const RzTypeDB *typedb, RZ_NONNULL const char *name, bool is_const) {
rz_return_val_if_fail(typedb && name, NULL);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return NULL;
}
return rz_type_pointer_of_base_type(typedb, btype, is_const);
}
/**
* \brief Creates a new pointer RzType from the given RzType
*
* \param typedb Type Database instance
* \param type RzType pointer
* \param is_const Set the pointer to "const" if true
*/
RZ_API RZ_OWN RzType *rz_type_pointer_of_type(const RzTypeDB *typedb, RZ_NONNULL RzType *type, bool is_const) {
rz_return_val_if_fail(typedb && type, NULL);
RzType *newtype = RZ_NEW0(RzType);
if (!newtype) {
return NULL;
}
newtype->kind = RZ_TYPE_KIND_POINTER;
newtype->pointer.type = type;
newtype->pointer.is_const = is_const;
return newtype;
}
/**
* \brief Creates a new array RzType from the given RzBaseType
*
* \param typedb Type Database instance
* \param btype RzBaseType pointer
* \param count The number of the array elements
*/
RZ_API RZ_OWN RzType *rz_type_array_of_base_type(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *btype, size_t count) {
RzType *type = RZ_NEW0(RzType);
if (!type) {
return NULL;
}
RzType *t = rz_type_identifier_of_base_type(typedb, btype, false);
if (!t) {
rz_type_free(type);
return NULL;
}
type->kind = RZ_TYPE_KIND_ARRAY;
type->array.type = t;
type->array.count = count;
return type;
}
/**
* \brief Creates a new array RzType from the given RzBaseType name
*
* \param typedb Type Database instance
* \param name RzBaseType name
* \param count The number of the array elements
*/
RZ_API RZ_OWN RzType *rz_type_array_of_base_type_str(const RzTypeDB *typedb, RZ_NONNULL const char *name, size_t count) {
rz_return_val_if_fail(typedb && name && count, NULL);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype) {
return NULL;
}
return rz_type_array_of_base_type(typedb, btype, count);
}
/**
* \brief Creates a new array RzType from the given RzType
*
* \param typedb Type Database instance
* \param type RzType pointer
* \param count The number of the array elements
*/
RZ_API RZ_OWN RzType *rz_type_array_of_type(const RzTypeDB *typedb, RZ_NONNULL RzType *type, size_t count) {
RzType *newtype = RZ_NEW0(RzType);
if (!newtype) {
return NULL;
}
newtype->kind = RZ_TYPE_KIND_ARRAY;
newtype->array.type = type;
newtype->array.count = count;
return newtype;
}
/**
* \brief Creates a new callable RzType of the given callable
*
* \param callable ownership transferred into the returned type
*/
RZ_API RZ_OWN RzType *rz_type_callable(RZ_NONNULL RZ_OWN RzCallable *callable) {
rz_return_val_if_fail(callable, NULL);
RzType *newtype = RZ_NEW0(RzType);
if (!newtype) {
return NULL;
}
newtype->kind = RZ_TYPE_KIND_CALLABLE;
newtype->callable = callable;
return newtype;
}
// Equivalence checking
/**
* \brief Checks if two atomic RzTypes are equivalent
*
* \param typedb Type Database instance
* \param typ1 First RzType type
* \param typ2 Second RzType type
*/
RZ_API bool rz_type_atomic_eq(const RzTypeDB *typedb, RZ_NONNULL const RzType *typ1, RZ_NONNULL const RzType *typ2) {
// We aim to compare only atomic types, we can't compare more complex ones for now
rz_return_val_if_fail(typ1 && typ2, false);
rz_return_val_if_fail(typ1->kind == RZ_TYPE_KIND_IDENTIFIER && typ2->kind == RZ_TYPE_KIND_IDENTIFIER, false);
rz_return_val_if_fail(typ1->identifier.kind == RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED, false);
rz_return_val_if_fail(typ2->identifier.kind == RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED, false);
rz_return_val_if_fail(typ1->identifier.name, false);
rz_return_val_if_fail(typ2->identifier.name, false);
RzBaseType *btyp1 = rz_type_db_get_base_type(typedb, typ1->identifier.name);
RzBaseType *btyp2 = rz_type_db_get_base_type(typedb, typ2->identifier.name);
if (!btyp1 || !btyp2) {
return false;
}
rz_return_val_if_fail(btyp1->kind == RZ_BASE_TYPE_KIND_ATOMIC && btyp2->kind == RZ_BASE_TYPE_KIND_ATOMIC, false);
return btyp1->name == btyp2->name && btyp1->size == btyp2->size;
// TODO: Should we also compare the btyp->type?
}
/**
* \brief Checks if two atomic types (RzType and RzBaseType) are equivalent
*
* \param typedb Type Database instance
* \param typ1 First RzType type
* \param typ2 Second RzBaseType type name
*/
RZ_API bool rz_type_atomic_str_eq(const RzTypeDB *typedb, RZ_NONNULL const RzType *typ1, RZ_NONNULL const char *name) {
// We aim to compare only atomic types, we can't compare more complex ones for now
rz_return_val_if_fail(typ1 && name, false);
rz_return_val_if_fail(typ1->kind == RZ_TYPE_KIND_IDENTIFIER, false);
rz_return_val_if_fail(typ1->identifier.kind == RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED, false);
rz_return_val_if_fail(typ1->identifier.name, false);
RzBaseType *btyp1 = rz_type_db_get_base_type(typedb, typ1->identifier.name);
RzBaseType *btyp2 = rz_type_db_get_base_type(typedb, name);
if (!btyp1 || !btyp2) {
return false;
}
rz_return_val_if_fail(btyp1->kind == RZ_BASE_TYPE_KIND_ATOMIC && btyp2->kind == RZ_BASE_TYPE_KIND_ATOMIC, false);
return btyp1->name == btyp2->name && btyp1->size == btyp2->size;
// TODO: Should we also compare the btyp->type?
}
// Here we provide helpers for some commonly used RzTypes for use within the analysis
/**
* \brief Checks if the RzType is "void"
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_atomic_is_void(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
if (type->kind != RZ_TYPE_KIND_IDENTIFIER) {
return false;
}
return !strcmp(type->identifier.name, "void");
}
/**
* \brief Checks if the atomic RzType is "const"
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_atomic_is_const(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
if (type->kind != RZ_TYPE_KIND_IDENTIFIER) {
return false;
}
return type->identifier.is_const;
}
/**
* \brief Checks if the pointer RzType is "const"
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_pointer_is_const(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
if (type->kind != RZ_TYPE_KIND_POINTER) {
return false;
}
return type->pointer.is_const;
}
static bool type_is_atomic_ptr(RZ_NONNULL const RzType *type, RZ_NONNULL const char *name) {
rz_return_val_if_fail(type && name, false);
if (type->kind != RZ_TYPE_KIND_POINTER) {
return false;
}
// There should not exist pointers to the empty types
RzType *ptr = type->pointer.type;
rz_return_val_if_fail(ptr, false);
return ptr->kind == RZ_TYPE_KIND_IDENTIFIER && ptr->identifier.kind == RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED && !strcmp(ptr->identifier.name, name);
}
static bool type_is_atomic_ptr_nested(RZ_NONNULL const RzType *type, RZ_NONNULL const char *name) {
rz_return_val_if_fail(type && name, false);
if (type->kind != RZ_TYPE_KIND_POINTER) {
return false;
}
// There should not exist pointers to the empty types
RzType *ptr = type->pointer.type;
rz_return_val_if_fail(ptr, false);
if (ptr->kind == RZ_TYPE_KIND_POINTER) {
return type_is_atomic_ptr_nested(ptr, name);
}
return ptr->kind == RZ_TYPE_KIND_IDENTIFIER && ptr->identifier.kind == RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED && !strcmp(ptr->identifier.name, name);
}
/**
* \brief Checks if the pointer RzType is abstract pointer ("void *")
*
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_void_ptr(RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
return type_is_atomic_ptr(type, "void");
}
/**
* \brief Checks if the pointer RzType is a nested abstract pointer ("void **", "vpod ***", etc)
*
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_void_ptr_nested(RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
return type_is_atomic_ptr_nested(type, "void");
}
/**
* \brief Checks if the pointer RzType is a string ("char *" or "const char *")
*
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_char_ptr(RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
return type_is_atomic_ptr(type, "char");
}
/**
* \brief Checks if the pointer RzType is a nested pointer of string ("char **", "char ***", etc)
*
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_char_ptr_nested(RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
return type_is_atomic_ptr_nested(type, "char");
}
/**
* \brief Checks if the RzType is identifier
*
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_identifier(RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
return type->kind == RZ_TYPE_KIND_IDENTIFIER;
}
/**
* \brief Checks if the RzType is strictly atomic
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_strictly_atomic(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
if (type->kind != RZ_TYPE_KIND_IDENTIFIER) {
return false;
}
if (type->identifier.kind != RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED) {
return false;
}
rz_return_val_if_fail(type->identifier.name, false);
RzBaseType *btyp = rz_type_db_get_base_type(typedb, type->identifier.name);
if (!btyp) {
return false;
}
return btyp->kind == RZ_BASE_TYPE_KIND_ATOMIC;
}
/**
* \brief Checks if the RzType is atomic or derivative of it
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_atomic(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
if (type->kind == RZ_TYPE_KIND_POINTER) {
return rz_type_is_atomic(typedb, type->pointer.type);
}
if (type->kind == RZ_TYPE_KIND_ARRAY) {
return rz_type_is_atomic(typedb, type->array.type);
}
if (type->kind != RZ_TYPE_KIND_IDENTIFIER) {
return false;
}
if (type->identifier.kind != RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED) {
return false;
}
rz_return_val_if_fail(type->identifier.name, false);
RzBaseType *btyp = rz_type_db_get_base_type(typedb, type->identifier.name);
if (!btyp) {
return false;
}
return btyp->kind == RZ_BASE_TYPE_KIND_ATOMIC;
}
/**
* \brief Checks if the RzType is default
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_is_default(const RzTypeDB *typedb, RZ_NONNULL const RzType *type) {
rz_return_val_if_fail(type, false);
if (type->kind != RZ_TYPE_KIND_IDENTIFIER) {
return false;
}
if (type->identifier.kind != RZ_TYPE_IDENTIFIER_KIND_UNSPECIFIED) {
return false;
}
return !strcmp(type->identifier.name, typedb->target->default_type) && !type->identifier.is_const;
}
/**
* \brief Creates a new instance of the default RzType type
*
* \param typedb Type Database instance
*/
RZ_API RZ_OWN RzType *rz_type_new_default(const RzTypeDB *typedb) {
rz_return_val_if_fail(typedb, NULL);
RzBaseType *btype = rz_type_db_get_base_type(typedb, typedb->target->default_type);
if (!btype) {
return NULL;
}
return rz_type_identifier_of_base_type(typedb, btype, false);
}
/**
* \brief If the type is unsigned it sets the sign
*
* \param typedb Type Database instance
* \param type RzType type pointer
*/
RZ_API bool rz_type_integral_set_sign(const RzTypeDB *typedb, RZ_NONNULL RzType **type, bool sign) {
rz_return_val_if_fail(type && *type, false);
RzType *t = *type;
if (t->kind != RZ_TYPE_KIND_IDENTIFIER) {
return false;
}
if (rz_type_is_integral(typedb, t)) {
const char *identifier = rz_type_identifier(t);
if (!identifier) {
return false;
}
RzBaseType *btype = rz_type_db_get_base_type(typedb, identifier);
if (!btype) {
return false;
}
RzTypeTypeclass typesubclass = sign ? RZ_TYPE_TYPECLASS_INTEGRAL_SIGNED : RZ_TYPE_TYPECLASS_INTEGRAL_UNSIGNED;
// We only change typesubclass if it's different from the current one
if (rz_base_type_typeclass(typedb, btype) == typesubclass) {
return true;
}
size_t typesize = rz_type_db_base_get_bitsize(typedb, btype);
RzBaseType *signedbtype = rz_type_typeclass_get_default_sized(typedb, typesubclass, typesize);
if (!signedbtype) {
return false;
}
RzType *signedtype = rz_type_identifier_of_base_type(typedb, signedbtype, false);
if (!signedtype) {
return false;
}
rz_type_free(t);
*type = signedtype;
}
return false;
}
/**
* \brief RzTypeCond enum to string
*
* \param cc RzTypeCond
* \return const char *
*/
RZ_API RZ_BORROW const char *rz_type_cond_tostring(RzTypeCond cc) {
switch (cc) {
case RZ_TYPE_COND_EQ: return "eq";
case RZ_TYPE_COND_NV: return "nv";
case RZ_TYPE_COND_NE: return "ne";
case RZ_TYPE_COND_HS: return "hs";
case RZ_TYPE_COND_LO: return "lo";
case RZ_TYPE_COND_MI: return "mi";
case RZ_TYPE_COND_PL: return "pl";
case RZ_TYPE_COND_VS: return "vs";
case RZ_TYPE_COND_VC: return "vc";
case RZ_TYPE_COND_HI: return "hi";
case RZ_TYPE_COND_LS: return "ls";
case RZ_TYPE_COND_GE: return "ge";
case RZ_TYPE_COND_LT: return "lt";
case RZ_TYPE_COND_GT: return "gt";
case RZ_TYPE_COND_LE: return "le";
case RZ_TYPE_COND_AL: return "al";
case RZ_TYPE_COND_HEX_SCL_TRUE: return "scl-t";
case RZ_TYPE_COND_HEX_SCL_FALSE: return "scl-f";
case RZ_TYPE_COND_HEX_VEC_TRUE: return "vec-t";
case RZ_TYPE_COND_HEX_VEC_FALSE: return "vec-f";
case RZ_TYPE_COND_EXCEPTION: return "excptn";
}
return "??";
}
/**
* \brief return the inverted condition
*
* \param cond RzTypeCond
* \return RzTypeCond
*/
RZ_API RzTypeCond rz_type_cond_invert(RzTypeCond cond) {
switch (cond) {
case RZ_TYPE_COND_LE:
return RZ_TYPE_COND_GT;
case RZ_TYPE_COND_LT:
return RZ_TYPE_COND_GE;
case RZ_TYPE_COND_GE:
return RZ_TYPE_COND_LT;
case RZ_TYPE_COND_GT:
return RZ_TYPE_COND_LE;
case RZ_TYPE_COND_AL:
return RZ_TYPE_COND_NV;
case RZ_TYPE_COND_NE:
return RZ_TYPE_COND_EQ;
case RZ_TYPE_COND_EQ:
return RZ_TYPE_COND_NE;
default:
rz_warn_if_reached();
break;
}
return 0;
}
/**
* \brief evaluate the type condition on the arguments and return a bool accordingly.
*
* \param cond RzTypeCond
* \param arg0
* \param arg1
* \return bool
*/
RZ_API bool rz_type_cond_eval(RzTypeCond cond, st64 arg0, st64 arg1) {
switch (cond) {
case RZ_TYPE_COND_EQ: return arg0 == arg1;
case RZ_TYPE_COND_NE: return arg0 != arg1;
case RZ_TYPE_COND_GE: return arg0 >= arg1;
case RZ_TYPE_COND_GT: return arg0 > arg1;
case RZ_TYPE_COND_LE: return arg0 <= arg1;
case RZ_TYPE_COND_LT: return arg0 < arg1;
default: return false;
}
return false;
}
/**
* \brief Same as rz_type_cond_eval, but it assumes \p arg1 to be 0.
*
* \param cond RzTypeCond
* \param arg0
* \return bool
*/
RZ_API bool rz_type_cond_eval_single(RzTypeCond cond, st64 arg0) {
switch (cond) {
case RZ_TYPE_COND_EQ: return !arg0;
case RZ_TYPE_COND_NE: return arg0;
case RZ_TYPE_COND_GT: return arg0 > 0;
case RZ_TYPE_COND_GE: return arg0 >= 0;
case RZ_TYPE_COND_LT: return arg0 < 0;
case RZ_TYPE_COND_LE: return arg0 <= 0;
default: return false;
}
return false;
}
rizin-0.7.4/librz/type/path.c 0000664 0001750 0001750 00000023166 14731035230 015430 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
/**
* \brief Creates a new instance of RzTypePath
*
* \param type RzType pointer
* \param path String representation of type path
*/
RZ_API RZ_OWN RzTypePath *rz_type_path_new(RZ_BORROW RZ_NONNULL RzType *type, RZ_OWN RZ_NONNULL char *path) {
rz_return_val_if_fail(type && path, NULL);
RzTypePath *tpath = RZ_NEW0(RzTypePath);
if (!tpath) {
return NULL;
}
tpath->typ = type;
tpath->path = path;
return tpath;
}
/**
* \brief Frees the RzTypePath
*
* Doesn't free the underlying RzBaseType, only the path.
*
* \param type RzTypePath
*/
RZ_API void rz_type_path_free(RZ_NULLABLE RzTypePath *tpath) {
if (!tpath) {
return;
}
free(tpath->path);
free(tpath);
}
static st64 path_walker(const RzTypeDB *typedb, const char *path) {
rz_return_val_if_fail(typedb && path, -1);
const char *member;
size_t membsize;
ut64 index;
st64 offset = 0;
RzType *parent = NULL;
const char *path_begin = path;
while (*path) {
switch (*path++) {
case '\0':
break;
case '[':
member = path;
index = (ut64)strtoull(member, (char **)&path, 10);
if (member == path || *path != ']') {
eprintf("Type path: expected ] (\"%s\")", path - 1);
return -1;
}
++path;
if (!parent || parent->kind != RZ_TYPE_KIND_ARRAY) {
return -1;
}
offset += rz_type_db_get_bitsize(typedb, parent) * index;
break;
case '.':
member = path;
for (membsize = 0; member[membsize]; ++membsize) {
if (strchr(".[", member[membsize])) {
break;
}
}
if (membsize == 0) {
eprintf("Type path: expected member (\"%s\")", path - 1);
return -1;
}
if (!parent) {
if (member <= path) {
return -1;
}
size_t typenamesize = member - path_begin;
char *typename = malloc(typenamesize + 1);
if (!typename) {
return -1;
}
strncpy(typename, path_begin, typenamesize);
typename[typenamesize] = '\0';
parent = rz_type_identifier_of_base_type_str(typedb, typename);
free(typename);
if (!parent) {
return -1;
}
} else {
if (parent->kind != RZ_TYPE_KIND_IDENTIFIER) {
return -1;
}
if (parent->identifier.kind != RZ_TYPE_IDENTIFIER_KIND_STRUCT && parent->identifier.kind != RZ_TYPE_IDENTIFIER_KIND_UNION) {
return -1;
}
}
offset += rz_type_db_struct_member_packed_offset(typedb, parent->identifier.name, member);
path = member + membsize;
break;
default:
eprintf("Type path: unexpected char (\"%s\")", path - 1);
return -1;
}
}
return offset;
}
/**
* \brief Returns the offset of the member given path
*
* Resolves the path in the form of "a.b[20].c" where "b" is
* a member of "a" and "c" is a member of "b" array and located
* inside the 20-th element, and calculates the offset.
* Opposite function of "rz_type_path_by_offset"
*
* \param type RzTypePath
*/
RZ_API st64 rz_type_offset_by_path(const RzTypeDB *typedb, RZ_NONNULL const char *path) {
rz_return_val_if_fail(typedb && path, -1);
return path_walker(typedb, path);
}
static void collect_type_paths(const RzTypeDB *typedb, RzList /**/ *list, const RzType *type, char *prefix, ut64 offset, unsigned int depth);
static void collect_base_type_paths(const RzTypeDB *typedb, RzList /**/ *list, const RzBaseType *btype, char *prefix, ut64 offset, unsigned int depth) {
rz_return_if_fail(typedb && list && btype && prefix);
if (!depth) {
return;
}
switch (btype->kind) {
case RZ_BASE_TYPE_KIND_STRUCT: {
RzTypeStructMember *memb;
ut64 memb_offset = 0;
rz_vector_foreach(&btype->struct_data.members, memb) {
if (memb_offset == offset) {
RzTypePath *tpath = rz_type_path_new(memb->type, rz_str_newf("%s.%s", prefix, memb->name));
if (tpath) {
rz_list_append(list, tpath);
}
}
ut64 bytesz = rz_type_db_get_bitsize(typedb, memb->type) / 8;
if (memb_offset + bytesz > offset) {
char *newpath = rz_str_newf("%s.%s", prefix, memb->name);
collect_type_paths(typedb, list, memb->type, newpath, offset - memb_offset, depth - 1);
free(newpath);
break;
}
memb_offset += bytesz;
}
break;
}
case RZ_BASE_TYPE_KIND_UNION: {
RzTypeUnionMember *memb;
rz_vector_foreach(&btype->union_data.members, memb) {
char *newpath = rz_str_newf("%s.%s", prefix, memb->name);
if (offset == 0) {
RzTypePath *tpath = rz_type_path_new(memb->type, newpath);
if (tpath) {
rz_list_append(list, tpath);
}
}
collect_type_paths(typedb, list, memb->type, newpath, offset, depth - 1);
if (offset != 0) {
free(newpath);
}
}
break;
}
case RZ_BASE_TYPE_KIND_TYPEDEF: {
RzType *ttype = rz_type_db_base_type_unwrap_typedef(typedb, btype);
if (!ttype) {
return;
}
collect_type_paths(typedb, list, ttype, prefix, offset, depth); // depth not decreased because this is not a visible step in the path
break;
}
default:
break;
}
}
static void collect_type_paths(const RzTypeDB *typedb, RzList /**/ *list, const RzType *type, char *prefix, ut64 offset, unsigned int depth) {
rz_return_if_fail(typedb && list && type && prefix);
if (!depth) {
return;
}
switch (type->kind) {
case RZ_TYPE_KIND_IDENTIFIER: {
rz_return_if_fail(type->identifier.name);
RzBaseType *btype = rz_type_db_get_base_type(typedb, type->identifier.name);
if (!btype) {
return;
}
collect_base_type_paths(typedb, list, btype, prefix, offset, depth); // depth not decreased because this is not a visible step in the path
break;
}
case RZ_TYPE_KIND_ARRAY: {
rz_return_if_fail(type->array.type);
ut64 stride = rz_type_db_get_bitsize(typedb, type->array.type) / 8;
if (!stride) {
break;
}
ut64 idx = offset / stride;
if (idx >= type->array.count) {
break;
}
ut64 idx_offset = offset - idx * stride;
char *newpath = rz_str_newf("%s[%" PFMT64u "]", prefix, idx);
if (idx_offset == 0) {
RzTypePath *tpath = rz_type_path_new(type->array.type, newpath);
if (tpath) {
rz_list_append(list, tpath);
}
}
collect_type_paths(typedb, list, type->array.type, newpath, idx_offset, depth - 1);
if (idx_offset != 0) {
free(newpath);
}
break;
}
default:
break;
}
}
/**
* \brief Returns the list of all paths into the base type matching the offset
*
* \param btype The root type from which paths are searched
* \param offset The offset into \p btype to match against
* \param max_depth Maximum number of components a path may have
*/
RZ_API RZ_OWN RzList /**/ *rz_base_type_path_by_offset(const RzTypeDB *typedb, const RzBaseType *btype, ut64 offset, unsigned int max_depth) {
rz_return_val_if_fail(typedb && btype && btype->name, NULL);
RzList *list = rz_list_newf((RzListFree)rz_type_path_free);
if (!list) {
return NULL;
}
collect_base_type_paths(typedb, list, btype, "", offset, max_depth);
return list;
}
/**
* \brief Returns the list of all paths into the type matching the offset
*
* \param type The root type from which paths are searched
* \param offset The offset into \p btype to match against
* \param max_depth Maximum number of components a path may have
*/
RZ_API RZ_OWN RzList /**/ *rz_type_path_by_offset(const RzTypeDB *typedb, const RzType *type, ut64 offset, unsigned int max_depth) {
rz_return_val_if_fail(typedb && type, NULL);
RzList *list = rz_list_newf((RzListFree)rz_type_path_free);
if (!list) {
return NULL;
}
collect_type_paths(typedb, list, type, "", offset, max_depth);
return list;
}
/**
* \brief Returns the list of all structured types that have members matching the offset
*
* \param typedb Types Database instance
* \param offset The offset of the member to match against
*/
RZ_API RZ_OWN RzList /**/ *rz_type_db_get_by_offset(const RzTypeDB *typedb, ut64 offset) {
rz_return_val_if_fail(typedb, NULL);
RzList *types = rz_type_db_get_base_types(typedb);
RzList *result = rz_list_newf((RzListFree)rz_type_path_free);
RzListIter *iter;
RzBaseType *t;
rz_list_foreach (types, iter, t) {
if (t->kind == RZ_BASE_TYPE_KIND_STRUCT || t->kind == RZ_BASE_TYPE_KIND_UNION) {
collect_base_type_paths(typedb, result, t, t->name, offset, 1);
}
}
rz_list_free(types);
return result;
}
/**
* \brief Returns the packed offset in bits of the structure member if there is a match
*
* \param typedb Types Database instance
* \param name The structure type name
* \param name The structure member name
*/
RZ_API ut64 rz_type_db_struct_member_packed_offset(RZ_NONNULL const RzTypeDB *typedb, RZ_NONNULL const char *name, RZ_NONNULL const char *member) {
rz_return_val_if_fail(typedb && name && member, 0);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype || btype->kind != RZ_BASE_TYPE_KIND_STRUCT) {
return 0;
}
RzTypeStructMember *memb;
ut64 result = 0;
rz_vector_foreach(&btype->struct_data.members, memb) {
if (!strcmp(memb->name, member)) {
return result;
break;
}
result += rz_type_db_get_bitsize(typedb, memb->type);
}
return result;
}
/**
* \brief Returns the offset in bytes of the structure member if there is a match
*
* \param typedb Types Database instance
* \param name The structure type name
* \param name The structure member name
*/
RZ_API ut64 rz_type_db_struct_member_offset(RZ_NONNULL const RzTypeDB *typedb, RZ_NONNULL const char *name, RZ_NONNULL const char *member) {
rz_return_val_if_fail(typedb && name && member, 0);
RzBaseType *btype = rz_type_db_get_base_type(typedb, name);
if (!btype || btype->kind != RZ_BASE_TYPE_KIND_STRUCT) {
return 0;
}
RzTypeStructMember *memb;
rz_vector_foreach(&btype->struct_data.members, memb) {
if (!strcmp(memb->name, member)) {
return memb->offset;
}
}
return 0;
}
rizin-0.7.4/librz/type/base.c 0000664 0001750 0001750 00000026413 14731035230 015404 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 Anton Kochkov
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
RZ_API void rz_type_base_enum_case_free(void *e, void *user) {
(void)user;
RzTypeEnumCase *cas = e;
free((char *)cas->name);
}
RZ_API void rz_type_base_struct_member_free(void *e, void *user) {
(void)user;
RzTypeStructMember *member = e;
rz_type_free(member->type);
free((char *)member->name);
}
RZ_API void rz_type_base_union_member_free(void *e, void *user) {
(void)user;
RzTypeUnionMember *member = e;
rz_type_free(member->type);
free((char *)member->name);
}
/**
* \brief Returns string representing the kind of base type
*
* \param kind RzBaseTypeKind to return string representation of
*/
RZ_API RZ_BORROW const char *rz_type_base_type_kind_as_string(RzBaseTypeKind kind) {
switch (kind) {
case RZ_BASE_TYPE_KIND_STRUCT:
return "struct";
case RZ_BASE_TYPE_KIND_UNION:
return "union";
case RZ_BASE_TYPE_KIND_ENUM:
return "enum";
case RZ_BASE_TYPE_KIND_TYPEDEF:
return "typedef";
case RZ_BASE_TYPE_KIND_ATOMIC:
return "atomic";
default:
rz_warn_if_reached();
return "unknown";
}
}
/**
* \brief Searches for the RzBaseType in the types database given the name
*
* \param typedb Type Database instance
* \param name Name of the RzBaseType
*/
RZ_API RZ_BORROW RzBaseType *rz_type_db_get_base_type(const RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(typedb && name, NULL);
bool found = false;
RzBaseType *btype = ht_pp_find(typedb->types, name, &found);
if (!found || !btype) {
return NULL;
}
return btype;
}
/**
* \brief Removes RzBaseType from the Types DB
*
* \param typedb Type Database instance
* \param type RzBaseType to remove
*/
RZ_API bool rz_type_db_delete_base_type(RzTypeDB *typedb, RZ_NONNULL RzBaseType *type) {
rz_return_val_if_fail(typedb && type && type->name, false);
ht_pp_delete(typedb->types, type->name);
return true;
}
struct list_kind {
RzList /**/ *types;
RzBaseTypeKind kind;
};
static bool base_type_kind_collect_cb(void *user, const void *k, const void *v) {
struct list_kind *l = user;
RzBaseType *btype = (RzBaseType *)v;
if (l->kind == btype->kind) {
rz_list_append(l->types, btype);
}
return true;
}
/**
* \brief Returns the list of all basic types of the chosen kind
*
* \param typedb Types Database instance
* \param kind Kind of the types to list
*/
RZ_API RZ_OWN RzList /**/ *rz_type_db_get_base_types_of_kind(const RzTypeDB *typedb, RzBaseTypeKind kind) {
rz_return_val_if_fail(typedb, NULL);
RzList *types = rz_list_new();
struct list_kind lk = { types, kind };
ht_pp_foreach(typedb->types, base_type_kind_collect_cb, &lk);
return types;
}
static bool base_type_collect_cb(void *user, const void *k, const void *v) {
rz_return_val_if_fail(user && k && v, false);
RzList *l = user;
rz_list_append(l, (void *)v);
return true;
}
/**
* \brief Returns the list of all basic types
*
* \param typedb Types Database instance
*/
RZ_API RZ_OWN RzList /**/ *rz_type_db_get_base_types(const RzTypeDB *typedb) {
rz_return_val_if_fail(typedb, NULL);
RzList *types = rz_list_new();
ht_pp_foreach(typedb->types, base_type_collect_cb, types);
return types;
}
static void RzTypeStructMember_cpy(RzTypeStructMember *dst, RzTypeStructMember *src) {
if (!(src && dst)) {
return;
}
memcpy(dst, src, sizeof(RzTypeStructMember));
dst->name = rz_str_dup(src->name);
dst->type = rz_type_clone(src->type);
}
static void RzTypeEnumCase_cpy(RzTypeEnumCase *dst, RzTypeEnumCase *src) {
if (!(src && dst)) {
return;
}
memcpy(dst, src, sizeof(RzTypeEnumCase));
dst->name = rz_str_dup(src->name);
}
static void RzTypeUnionMember_cpy(RzTypeUnionMember *dst, RzTypeUnionMember *src) {
if (!(src && dst)) {
return;
}
memcpy(dst, src, sizeof(RzTypeUnionMember));
dst->name = rz_str_dup(src->name);
dst->type = rz_type_clone(src->type);
}
/**
* \brief Copy RzBaseType \p src into another RzBaseType \p dst
* \param dst the destination RzBaseType
* \param src the source RzBaseType
* \return true if the copy was successful, false otherwise
*/
RZ_API bool rz_base_type_clone_into(
RZ_NONNULL RZ_BORROW RZ_OUT RzBaseType *dst,
RZ_NONNULL RZ_BORROW RZ_IN RzBaseType *src) {
rz_return_val_if_fail(src && dst, false);
rz_mem_copy(dst, sizeof(RzBaseType), src, sizeof(RzBaseType));
dst->name = rz_str_dup(src->name);
dst->type = src->type ? rz_type_clone(src->type) : NULL;
switch (src->kind) {
case RZ_BASE_TYPE_KIND_ENUM:
rz_vector_clone_intof(&dst->enum_data.cases, &src->enum_data.cases,
(RzVectorItemCpyFunc)RzTypeEnumCase_cpy);
break;
case RZ_BASE_TYPE_KIND_STRUCT:
rz_vector_clone_intof(&dst->struct_data.members, &src->struct_data.members,
(RzVectorItemCpyFunc)RzTypeStructMember_cpy);
break;
case RZ_BASE_TYPE_KIND_UNION:
rz_vector_clone_intof(&dst->union_data.members, &src->union_data.members,
(RzVectorItemCpyFunc)RzTypeUnionMember_cpy);
break;
default: break;
}
return true;
}
/**
* \brief Copy the RzBaseType \p b and all its members
* \param b the RzBaseType to copy
* \return a copy of \p b
*/
RZ_API RZ_OWN RzBaseType *rz_base_type_clone(RZ_NULLABLE RZ_BORROW RzBaseType *b) {
if (!b) {
return NULL;
}
RzBaseType *type = RZ_NEW0(RzBaseType);
if (!type) {
return NULL;
}
if (!rz_base_type_clone_into(type, b)) {
return NULL;
}
return type;
}
/**
* \brief Frees the RzBaseType instance and all of its members
*
* \param type RzBaseType pointer
*/
RZ_API void rz_type_base_type_free(RzBaseType *type) {
if (!type) {
return;
}
RZ_FREE(type->name);
rz_type_free(type->type);
type->type = NULL;
switch (type->kind) {
case RZ_BASE_TYPE_KIND_STRUCT:
rz_vector_fini(&type->struct_data.members);
break;
case RZ_BASE_TYPE_KIND_UNION:
rz_vector_fini(&type->union_data.members);
break;
case RZ_BASE_TYPE_KIND_ENUM:
rz_vector_fini(&type->enum_data.cases);
break;
case RZ_BASE_TYPE_KIND_TYPEDEF:
case RZ_BASE_TYPE_KIND_ATOMIC:
break;
default:
break;
}
RZ_FREE(type);
}
/**
* \brief Allocates a new instance of RzBaseType given the kind
*
* \param kind Kind of RzBaseType to create
*/
RZ_API RZ_OWN RzBaseType *rz_type_base_type_new(RzBaseTypeKind kind) {
RzBaseType *type = RZ_NEW0(RzBaseType);
if (!type) {
return NULL;
}
type->kind = kind;
switch (type->kind) {
case RZ_BASE_TYPE_KIND_STRUCT:
rz_vector_init(&type->struct_data.members, sizeof(RzTypeStructMember), rz_type_base_struct_member_free, NULL);
break;
case RZ_BASE_TYPE_KIND_ENUM:
rz_vector_init(&type->enum_data.cases, sizeof(RzTypeEnumCase), rz_type_base_enum_case_free, NULL);
break;
case RZ_BASE_TYPE_KIND_UNION:
rz_vector_init(&type->union_data.members, sizeof(RzTypeUnionMember), rz_type_base_union_member_free, NULL);
break;
default:
break;
}
return type;
}
/**
* \brief Saves RzBaseType into the Types DB
*
* \param typedb Type Database instance
* \param type RzBaseType to save
*/
RZ_API bool rz_type_db_save_base_type(const RzTypeDB *typedb, RzBaseType *type) {
rz_return_val_if_fail(typedb && type && type->name, false);
if (!ht_pp_insert(typedb->types, type->name, (void *)type)) {
rz_type_base_type_free(type);
return false;
}
return true;
}
/**
* \brief Updates the base type in the Types DB, frees the old one, frees the new one if it fails
*
* \param typedb Type Database instance
* \param type RzBaseType to save
*/
RZ_API bool rz_type_db_update_base_type(const RzTypeDB *typedb, RzBaseType *type) {
rz_return_val_if_fail(typedb && type && type->name, false);
if (!ht_pp_update(typedb->types, type->name, (void *)type)) {
rz_type_base_type_free(type);
return false;
}
return true;
}
/**
* \brief Returns C representation as string of RzBaseType (see rz_type_db_base_type_as_pretty_string for cusom print options)
*
* \param typedb type database instance
* \param btype RzBaseType to convert
* \return char* one line C representation of the string with no semicolon at the end and no unfolding of inner types
*/
RZ_API RZ_OWN char *rz_type_db_base_type_as_string(const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *btype) {
rz_return_val_if_fail(typedb && btype, NULL);
RzType *type = rz_type_identifier_of_base_type(typedb, btype, false);
char *ret = rz_type_as_pretty_string(typedb, type, NULL, RZ_TYPE_PRINT_NO_END_SEMICOLON | RZ_TYPE_PRINT_ZERO_VLA, 1);
rz_type_free(type);
return ret;
}
/**
* \brief Returns C representation as string of RzBaseType
*
* \param typedb type database instance
* \param btype RzBaseType to convert
* \param opts options for pretty printing (see RzTypePrintOpts)
* \param unfold_level level of unfolding to do in case of nested structures/unions (any negative number means maximum unfolding, i.e. INT32_MAX. 0 means no unfolding, just the typename and identifier, if any)
* \return char* pretty printed form of the base string (similar to `rz_type_as_pretty_string`, but for RzBaseType)
*/
RZ_API RZ_OWN char *rz_type_db_base_type_as_pretty_string(RZ_NONNULL const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *btype, unsigned int opts, int unfold_level) {
rz_return_val_if_fail(typedb && btype, NULL);
RzType *type = rz_type_identifier_of_base_type(typedb, btype, false);
return rz_type_as_pretty_string(typedb, type, NULL, opts, unfold_level);
}
/**
* \brief Searches for the compound RzBaseType in the types database given the name
*
* Returns all types except atomic - structures, unions, enums, typedefs
*
* \param typedb Type Database instance
* \param name Name of the RzBaseType
*/
RZ_API RZ_BORROW RzBaseType *rz_type_db_get_compound_type(const RzTypeDB *typedb, RZ_NONNULL const char *name) {
rz_return_val_if_fail(name, NULL);
RzBaseType *t = rz_type_db_get_base_type(typedb, name);
if (!t) {
RZ_LOG_ERROR("Cannot find type \"%s\"\n", name);
return NULL;
}
if (t->kind == RZ_BASE_TYPE_KIND_ATOMIC) {
RZ_LOG_ERROR("Atomic type \"%s\"\n", name);
return NULL;
}
return t;
}
/**
* \brief Recursively resolve a typedef to its pointed-to type
*
* The case where the typedef chain contains a loop, meaning a typedef eventually points
* to itself, is safely handled here and NULL is returned.
*
* \param btype a base type that must be of kind RZ_TYPE_KIND_TYPEDEF
* \return the first non-typedef type in the chain started by \p btype, or NULL on error or if there is a loop
*/
RZ_API RZ_BORROW RzType *rz_type_db_base_type_unwrap_typedef(RZ_NONNULL const RzTypeDB *typedb, RZ_NONNULL const RzBaseType *btype) {
rz_return_val_if_fail(typedb && btype && btype->kind == RZ_BASE_TYPE_KIND_TYPEDEF, NULL);
RzPVector visited_btypes; // for detecting self-referential typedefs (maybe in multiple steps)
rz_pvector_init(&visited_btypes, NULL);
RzType *ttype;
while (true) {
if (rz_pvector_contains(&visited_btypes, (void *)btype)) {
// loop detected
ttype = NULL;
goto end;
}
ttype = btype->type;
rz_return_val_if_fail(ttype, NULL);
if (ttype->kind != RZ_TYPE_KIND_IDENTIFIER) {
goto end;
}
RzBaseType *next_btype = rz_type_db_get_base_type(typedb, ttype->identifier.name);
if (!next_btype || next_btype->kind != RZ_BASE_TYPE_KIND_TYPEDEF) {
goto end;
}
// push to the vector as late as possible to avoid heap usage if possible
if (!rz_pvector_push(&visited_btypes, (void *)btype)) {
ttype = NULL;
goto end;
}
btype = next_btype;
}
end:
rz_pvector_fini(&visited_btypes);
return ttype;
}
rizin-0.7.4/librz/type/README.md 0000664 0001750 0001750 00000000000 14731035230 015565 0 ustar sophie sophie rizin-0.7.4/librz/diff/ 0000775 0001750 0001750 00000000000 14731035230 014247 5 ustar sophie sophie rizin-0.7.4/librz/diff/meson.build 0000664 0001750 0001750 00000001224 14731035230 016410 0 ustar sophie sophie rz_diff_sources = [
'diff.c',
'distance.c'
]
dependencies = [rz_util_dep]
rz_diff = library('rz_diff', rz_diff_sources,
include_directories: [platform_inc],
dependencies: dependencies,
install: true,
implicit_include_directories: false,
install_rpath: rpath_lib,
soversion: rizin_libversion,
version: rizin_version,
name_suffix: lib_name_suffix,
name_prefix: lib_name_prefix,
)
rz_diff_dep = declare_dependency(link_with: rz_diff,
include_directories: [platform_inc])
meson.override_dependency('rz_diff', rz_diff_dep)
modules += { 'rz_diff': {
'target': rz_diff,
'dependencies': ['rz_util']
}}
rizin-0.7.4/librz/diff/lines_diff.c 0000664 0001750 0001750 00000004111 14731035230 016512 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 RizinOrg
// SPDX-FileCopyrightText: 2021 deroad
// SPDX-License-Identifier: LGPL-3.0-only
/* Helpers for handling lines */
#define DIFF_IS_LINES_METHOD(x) (x.elem_at == methods_lines.elem_at)
static RzList /**/ *tokenize_lines(const char *string) {
RzList *lines = NULL;
size_t last = 0;
size_t size = 0;
char *line = NULL;
lines = rz_list_newf((RzListFree)free);
if (!lines) {
RZ_LOG_ERROR("rz_diff_line_new: cannot allocate list of lines\n");
goto tokenize_newlines_fail;
}
size = strlen(string);
for (size_t i = 0; i < size; ++i) {
if (string[i] == '\n') {
line = rz_str_ndup(string + last, (i + 1) - last);
if (!line || !rz_list_append(lines, line)) {
RZ_LOG_ERROR("rz_diff_line_new: cannot allocate line or add it to the list\n");
free(line);
goto tokenize_newlines_fail;
}
last = i + 1;
}
}
if (last < size) {
line = rz_str_ndup(string + last, size - last);
if (!line || !rz_list_append(lines, line)) {
RZ_LOG_ERROR("rz_diff_line_new: cannot allocate last line or add it to the list\n");
free(line);
goto tokenize_newlines_fail;
}
}
return lines;
tokenize_newlines_fail:
rz_list_free(lines);
return NULL;
}
static const void *line_elem_at(const RzList /**/ *array, ut32 index) {
return rz_list_get_n(array, index);
}
static int line_compare(const char *a_elem, const char *b_elem) {
return strcmp(a_elem, b_elem);
}
static ut32 line_hash(const char *elem) {
ut32 size = strlen(elem);
return rz_diff_hash_data((const ut8 *)elem, size);
}
static void line_stringify(const char *a_elem, RzStrBuf *sb) {
rz_strbuf_set(sb, a_elem);
}
static void line_free(RzList /**/ *array) {
rz_list_free(array);
}
static const MethodsInternal methods_lines = {
.elem_at /* */ = (RzDiffMethodElemAt)line_elem_at,
.elem_hash /**/ = (RzDiffMethodElemHash)line_hash,
.compare /* */ = (RzDiffMethodCompare)line_compare,
.stringify /**/ = (RzDiffMethodStringify)line_stringify,
.ignore /* */ = fake_ignore,
.free /* */ = (RzDiffMethodFree)line_free,
};
rizin-0.7.4/librz/diff/unified_diff.c 0000664 0001750 0001750 00000032051 14731035230 017027 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 RizinOrg
// SPDX-FileCopyrightText: 2021 deroad
// SPDX-License-Identifier: LGPL-3.0-only
#include
#define Color_RANGE Color_BBLUE
#define Color_INSERT Color_BGREEN
#define Color_DELETE Color_BRED
#define Color_BGINSERT "\x1b[48;5;22m"
#define Color_BGDELETE "\x1b[48;5;52m"
#define FAST_MOD2(x, y) ((x) & (y - 1))
#define FAST_MOD64(x) FAST_MOD2(x, 64)
#define DIFF_COLOR(prefix) (prefix == '+' ? Color_INSERT : (prefix == '-' ? Color_DELETE : ""))
#define DIFF_BGCOLOR(prefix) (prefix == '+' ? Color_BGINSERT : (prefix == '-' ? Color_BGDELETE : ""))
static inline ut32 count_newlines(RzDiff *diff, const void *array, st32 beg, st32 end) {
RzDiffMethodElemAt elem_at = diff->methods.elem_at;
RzDiffMethodStringify stringify = diff->methods.stringify;
int len = 0;
ut32 count = 0;
const char *p;
const void *elem;
RzStrBuf tmp;
for (st32 i = beg; i < end; ++i) {
rz_strbuf_init(&tmp);
elem = elem_at(array, i);
stringify(elem, &tmp);
len = rz_strbuf_length(&tmp);
p = rz_strbuf_get(&tmp);
if (len > 0 && p[len - 1] == '\n') {
count++;
}
rz_strbuf_fini(&tmp);
}
return count;
}
static inline void diff_unified_append_ranges(RzList /**/ *opcodes, RzStrBuf *sb, bool color) {
const char *color_beg = color ? Color_RANGE : "";
const char *color_end = color ? Color_RESET : "";
RzDiffOp *first = rz_list_first(opcodes);
RzDiffOp *last = rz_list_last(opcodes);
st32 a_len = last->a_end - first->a_beg;
st32 b_len = last->b_end - first->b_beg;
rz_strbuf_appendf(sb, "%s@@ -%d,%d +%d,%d @@%s\n", color_beg, first->a_beg + 1, a_len, first->b_beg + 1, b_len, color_end);
}
static inline void diff_unified_json_ranges(RzList /**/ *opcodes, PJ *pj) {
RzDiffOp *first = rz_list_first(opcodes);
RzDiffOp *last = rz_list_last(opcodes);
st32 a_len = last->a_end - first->a_beg;
st32 b_len = last->b_end - first->b_beg;
pj_ka(pj, "from");
pj_N(pj, first->a_beg + 1);
pj_N(pj, a_len);
pj_end(pj);
pj_ka(pj, "to");
pj_N(pj, first->b_beg + 1);
pj_N(pj, b_len);
pj_end(pj);
}
static inline void diff_unified_append_data(RzDiff *diff, const void *array, st32 beg, st32 end, RzStrBuf *sb, char prefix, bool color) {
RzDiffMethodElemAt elem_at = diff->methods.elem_at;
RzDiffMethodStringify stringify = diff->methods.stringify;
int len = 0;
ut32 count = 0;
const char *p;
const void *elem;
RzStrBuf tmp;
bool newline = false;
bool is_bytes = DIFF_IS_BYTES_METHOD(diff->methods);
if (beg < 0) {
beg = 0;
}
const char *bcol = color ? DIFF_COLOR(prefix) : "";
const char *ecol = color ? (Color_RESET) : "";
rz_strbuf_appendf(sb, "%s%c", bcol, prefix);
for (st32 i = beg; i < end; ++i) {
if (newline || (is_bytes && count > 0 && !FAST_MOD64(count))) {
rz_strbuf_appendf(sb, "%s\n%s%c", ecol, bcol, prefix);
newline = false;
}
rz_strbuf_init(&tmp);
elem = elem_at(array, i);
stringify(elem, &tmp);
len = rz_strbuf_length(&tmp);
p = rz_strbuf_get(&tmp);
count += len;
if (len > 0 && p[len - 1] == '\n') {
len--;
newline = true;
}
rz_strbuf_append_n(sb, p, len);
rz_strbuf_fini(&tmp);
}
rz_strbuf_appendf(sb, "%s\n", ecol);
}
// Assumes that color is true, diffing lines, op->type is RZ_DIFF_OP_REPLACE
// and that the number of inserted lines is equal to the number of deleted
// lines.
static inline void diff_unified_lines_hl(RzDiff *diff, RzDiffOp *op, RzStrBuf *sb, char del_prefix, char ins_prefix) {
RzDiffMethodElemAt elem_at = diff->methods.elem_at;
RzDiffMethodStringify stringify = diff->methods.stringify;
int len = 0;
const char *p;
const void *elem;
RzStrBuf tmp, tmp2;
const char *ecol = Color_RESET;
const char *ebgcol = Color_RESET_BG;
const void *a_array = diff->a;
st32 a_beg = op->a_beg;
if (a_beg < 0) {
a_beg = 0;
}
st32 a_end = op->a_end;
const void *b_array = diff->b;
st32 b_beg = op->b_beg;
if (b_beg < 0) {
b_beg = 0;
}
st32 b_end = op->b_end;
ut32 num_nl = count_newlines(diff, a_array, a_beg, a_end);
// + 1 just in case there's no nl at end
ut32 num_bounds = num_nl + 1;
st32 *char_bounds = malloc(sizeof(st32) * 2 * num_bounds);
if (!char_bounds) {
return;
}
for (ut32 i = 0; i < num_bounds; i++) {
char_bounds[i * 2] = char_bounds[i * 2 + 1] = -1;
}
// Fill char_bounds array
ut32 bounds_idx = 0;
bool newline = false;
st32 i = a_beg;
st32 j = b_beg;
for (; i < a_end; ++i) {
if (newline) {
bounds_idx++;
newline = false;
}
rz_strbuf_init(&tmp);
elem = elem_at(a_array, i);
stringify(elem, &tmp);
len = rz_strbuf_length(&tmp);
p = rz_strbuf_get(&tmp);
if (len > 0 && p[len - 1] == '\n') {
len--;
newline = true;
}
int len_b = 0;
const void *elem_b;
const char *p_b;
for (; j < b_end; ++j) {
rz_strbuf_init(&tmp2);
elem_b = elem_at(b_array, j);
stringify(elem_b, &tmp2);
len_b = rz_strbuf_length(&tmp2);
p_b = rz_strbuf_get(&tmp2);
if (len_b > 0 && p_b[len_b - 1] == '\n') {
len_b--;
}
if (len && len_b && (p[0] == p_b[0] || p[len - 1] == p_b[len_b - 1])) {
// Get left bound.
st32 left = 0;
for (; left < RZ_MIN(len, len_b) && p[left] == p_b[left]; left++)
;
char_bounds[bounds_idx * 2] = left;
// Get right bound (offset). "- left" chops off
// the left portion that has already matched.
st32 right = 0;
for (; right < RZ_MIN(len, len_b) - left && p[len - 1 - right] == p_b[len_b - 1 - right];
right++)
;
char_bounds[bounds_idx * 2 + 1] = right;
}
rz_strbuf_fini(&tmp2);
++j;
break;
}
rz_strbuf_fini(&tmp);
}
// Show deleted lines
char prefix = del_prefix;
const char *bcol = DIFF_COLOR(prefix);
const char *bbgcol = DIFF_BGCOLOR(prefix);
newline = false;
bounds_idx = 0;
rz_strbuf_appendf(sb, "%s%c", bcol, prefix);
for (st32 i = a_beg; i < a_end; ++i) {
if (newline) {
rz_strbuf_appendf(sb, "%s\n%s%c", ecol, bcol, prefix);
newline = false;
bounds_idx++;
}
rz_strbuf_init(&tmp);
elem = elem_at(a_array, i);
stringify(elem, &tmp);
len = rz_strbuf_length(&tmp);
p = rz_strbuf_get(&tmp);
if (len > 0 && p[len - 1] == '\n') {
len--;
newline = true;
}
st32 left = char_bounds[bounds_idx * 2];
st32 right = char_bounds[bounds_idx * 2 + 1];
if (left < 0 || right < 0 || len - right < left) {
rz_strbuf_append_n(sb, p, len);
} else {
rz_strbuf_append_n(sb, p, left);
rz_strbuf_append(sb, bbgcol);
rz_strbuf_append_n(sb, p + left, len - right - left);
rz_strbuf_append(sb, ebgcol);
rz_strbuf_append_n(sb, p + len - right, right);
}
rz_strbuf_fini(&tmp);
}
rz_strbuf_appendf(sb, "%s\n", ecol);
// Show inserted lines
prefix = ins_prefix;
bcol = DIFF_COLOR(prefix);
bbgcol = DIFF_BGCOLOR(prefix);
newline = false;
bounds_idx = 0;
rz_strbuf_appendf(sb, "%s%c", bcol, prefix);
for (st32 i = b_beg; i < b_end; ++i) {
if (newline) {
rz_strbuf_appendf(sb, "%s\n%s%c", ecol, bcol, prefix);
newline = false;
bounds_idx++;
}
rz_strbuf_init(&tmp);
elem = elem_at(b_array, i);
stringify(elem, &tmp);
len = rz_strbuf_length(&tmp);
p = rz_strbuf_get(&tmp);
if (len > 0 && p[len - 1] == '\n') {
len--;
newline = true;
}
st32 left = char_bounds[bounds_idx * 2];
st32 right = char_bounds[bounds_idx * 2 + 1];
if (left < 0 || right < 0 || len - right < left) {
rz_strbuf_append_n(sb, p, len);
} else {
rz_strbuf_append_n(sb, p, left);
rz_strbuf_append(sb, bbgcol);
rz_strbuf_append_n(sb, p + left, len - right - left);
rz_strbuf_append(sb, ebgcol);
rz_strbuf_append_n(sb, p + len - right, right);
}
rz_strbuf_fini(&tmp);
}
rz_strbuf_appendf(sb, "%s\n", ecol);
free(char_bounds);
}
static inline void diff_unified_json_data(RzDiff *diff, const void *array, st32 beg, st32 end, PJ *pj, const char *op) {
RzDiffMethodElemAt elem_at = diff->methods.elem_at;
RzDiffMethodStringify stringify = diff->methods.stringify;
int len = 0;
ut32 count = 0;
const char *p;
const void *elem;
RzStrBuf tmp;
bool newline = false;
bool is_bytes = DIFF_IS_BYTES_METHOD(diff->methods);
if (beg < 0) {
beg = 0;
}
pj_o(pj);
pj_ks(pj, "op", op);
rz_strbuf_init(&tmp);
for (st32 i = beg; i < end; ++i) {
if (newline || (is_bytes && count > 0 && !FAST_MOD64(count))) {
pj_ks(pj, "value", rz_strbuf_get(&tmp));
pj_end(pj);
rz_strbuf_fini(&tmp);
rz_strbuf_init(&tmp);
pj_o(pj);
pj_ks(pj, "op", op);
newline = false;
}
elem = elem_at(array, i);
stringify(elem, &tmp);
len = rz_strbuf_length(&tmp);
p = rz_strbuf_get(&tmp);
count += len;
if (len > 0 && p[len - 1] == '\n') {
newline = true;
}
}
pj_ks(pj, "value", rz_strbuf_get(&tmp));
pj_end(pj);
rz_strbuf_fini(&tmp);
}
/**
* \brief Produces a diff output with A and B inputs presented immediately adjacent to each other.
*
* Produces a diff output with A and B inputs presented immediately adjacent to each other.
* It begins with range information and is immediately followed with the line additions,
* line deletions, and any number of the contextual lines.
* */
RZ_API RZ_OWN char *rz_diff_unified_text(RZ_NONNULL RzDiff *diff, RZ_NULLABLE const char *from, RZ_NULLABLE const char *to, bool show_time, bool color) {
rz_return_val_if_fail(diff && diff->methods.elem_at && diff->methods.stringify, NULL);
RzStrBuf *sb = NULL;
RzList *groups = NULL;
RzList *opcodes = NULL;
RzDiffOp *op = NULL;
RzListIter *itg = NULL;
RzListIter *ito = NULL;
if (!from) {
from = "/original";
}
if (!to) {
to = "/modified";
}
sb = rz_strbuf_new("");
if (!sb) {
RZ_LOG_ERROR("rz_diff_unified: cannot allocate sb\n");
goto rz_diff_unified_text_fail;
}
if (show_time) {
char *time = rz_time_date_now_to_string();
rz_strbuf_appendf(sb, "--- %s %s\n+++ %s %s\n", from, (time ? time : ""), to, (time ? time : ""));
free(time);
} else {
rz_strbuf_appendf(sb, "--- %s\n+++ %s\n", from, to);
}
groups = rz_diff_opcodes_grouped_new(diff, RZ_DIFF_DEFAULT_N_GROUPS);
if (!groups) {
goto rz_diff_unified_text_fail;
}
rz_list_foreach (groups, itg, opcodes) {
if (rz_list_length(opcodes) < 1) {
continue;
}
diff_unified_append_ranges(opcodes, sb, color);
rz_list_foreach (opcodes, ito, op) {
if (op->type == RZ_DIFF_OP_EQUAL) {
diff_unified_append_data(diff, diff->a, op->a_beg, op->a_end, sb, ' ', color);
continue;
}
if (op->type == RZ_DIFF_OP_DELETE) {
diff_unified_append_data(diff, diff->a, op->a_beg, op->a_end, sb, '-', color);
} else if (op->type == RZ_DIFF_OP_INSERT) {
diff_unified_append_data(diff, diff->b, op->b_beg, op->b_end, sb, '+', color);
} else if (op->type == RZ_DIFF_OP_REPLACE) {
if (!color || !DIFF_IS_LINES_METHOD(diff->methods) ||
count_newlines(diff, diff->a, op->a_beg, op->a_end) !=
count_newlines(diff, diff->b, op->b_beg, op->b_end)) {
diff_unified_append_data(diff, diff->a, op->a_beg, op->a_end, sb, '-', color);
diff_unified_append_data(diff, diff->b, op->b_beg, op->b_end, sb, '+', color);
} else {
diff_unified_lines_hl(diff, op, sb, '-', '+');
}
}
}
}
rz_list_free(groups);
return rz_strbuf_drain(sb);
rz_diff_unified_text_fail:
rz_strbuf_free(sb);
rz_list_free(groups);
return NULL;
}
/**
* \brief Produces a diff output to convert A in B in a JSON format.
*
* Produces a diff output with A and B inputs and contains the operations required
* to convert A in B and the values to remove, insert or keep.
* */
RZ_API RZ_OWN PJ *rz_diff_unified_json(RZ_NONNULL RzDiff *diff, RZ_NULLABLE const char *from, RZ_NULLABLE const char *to, bool show_time) {
rz_return_val_if_fail(diff && diff->methods.elem_at && diff->methods.stringify, NULL);
PJ *pj = NULL;
RzList *groups = NULL;
RzList *opcodes = NULL;
RzDiffOp *op = NULL;
RzListIter *itg = NULL;
RzListIter *ito = NULL;
if (!from) {
from = "/original";
}
if (!to) {
to = "/modified";
}
pj = pj_new();
if (!pj) {
RZ_LOG_ERROR("rz_diff_unified: failed to allocate json\n");
goto rz_diff_unified_json_fail;
}
pj_o(pj);
if (show_time) {
char *time = rz_time_date_now_to_string();
if (!time) {
RZ_LOG_ERROR("rz_diff_unified: failed to allocate timestamp\n");
goto rz_diff_unified_json_fail;
}
pj_ks(pj, "timestamp", time);
free(time);
}
pj_ks(pj, "from", from);
pj_ks(pj, "to", to);
groups = rz_diff_opcodes_grouped_new(diff, RZ_DIFF_DEFAULT_N_GROUPS);
if (!groups) {
goto rz_diff_unified_json_fail;
}
pj_ka(pj, "diff");
rz_list_foreach (groups, itg, opcodes) {
if (rz_list_length(opcodes) < 1) {
continue;
}
pj_o(pj);
diff_unified_json_ranges(opcodes, pj);
pj_ka(pj, "ops");
rz_list_foreach (opcodes, ito, op) {
if (op->type == RZ_DIFF_OP_EQUAL) {
diff_unified_json_data(diff, diff->a, op->a_beg, op->a_end, pj, "equal");
continue;
}
if (op->type == RZ_DIFF_OP_DELETE || op->type == RZ_DIFF_OP_REPLACE) {
diff_unified_json_data(diff, diff->a, op->a_beg, op->a_end, pj, "delete");
}
if (op->type == RZ_DIFF_OP_INSERT || op->type == RZ_DIFF_OP_REPLACE) {
diff_unified_json_data(diff, diff->b, op->b_beg, op->b_end, pj, "insert");
}
}
pj_end(pj);
pj_end(pj);
}
pj_end(pj);
pj_end(pj);
rz_list_free(groups);
return pj;
rz_diff_unified_json_fail:
pj_free(pj);
rz_list_free(groups);
return NULL;
}
rizin-0.7.4/librz/diff/distance.c 0000664 0001750 0001750 00000006043 14731035230 016210 0 ustar sophie sophie // SPDX-FileCopyrightText: 2017 Fangrui Song
// SPDX-FileCopyrightText: 2016 NikolaiHampton
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
/**
* \brief Calculates the distance between two buffers using the Myers algorithm
*
* Calculates the distance between two buffers using the Eugene W. Myers' O(ND) diff algorithm.
* - distance: is the minimum number of edits needed to transform A into B
* - similarity: is a number that defines how similar/identical the 2 buffers are.
* */
RZ_API bool rz_diff_myers_distance(RZ_NONNULL const ut8 *a, ut32 la, RZ_NONNULL const ut8 *b, ut32 lb, RZ_NULLABLE ut32 *distance, RZ_NULLABLE double *similarity) {
rz_return_val_if_fail(a && b, false);
const ut32 length = la + lb;
const ut8 *ea = a + la, *eb = b + lb;
for (; a < ea && b < eb && *a == *b; a++, b++) {
}
for (; a < ea && b < eb && ea[-1] == eb[-1]; ea--, eb--) {
}
la = ea - a;
lb = eb - b;
ut32 *v0, *v;
st64 m = (st64)la + lb, di = 0, low, high, i, x, y;
if (m + 2 > SIZE_MAX / sizeof(st64) || !(v0 = malloc((m + 2) * sizeof(ut32)))) {
return false;
}
v = v0 + lb;
v[1] = 0;
for (di = 0; di <= m; di++) {
low = -di + 2 * RZ_MAX(0, di - (st64)lb);
high = di - 2 * RZ_MAX(0, di - (st64)la);
for (i = low; i <= high; i += 2) {
x = i == -di || (i != di && v[i - 1] < v[i + 1]) ? v[i + 1] : v[i - 1] + 1;
y = x - i;
while (x < la && y < lb && a[x] == b[y]) {
x++;
y++;
}
v[i] = x;
if (x == la && y == lb) {
goto out;
}
}
}
out:
free(v0);
if (distance) {
*distance = di;
}
if (similarity) {
*similarity = length ? 1.0 - (double)di / length : 1.0;
}
return true;
}
/**
* \brief Calculates the distance between two buffers using the Levenshtein algorithm
*
* Calculates the distance between two buffers using the Levenshtein distance algorithm.
* - distance: is the minimum number of edits needed to transform A into B
* - similarity: is a number that defines how similar/identical the 2 buffers are.
* */
RZ_API bool rz_diff_levenshtein_distance(RZ_NONNULL const ut8 *a, ut32 la, RZ_NONNULL const ut8 *b, ut32 lb, RZ_NULLABLE ut32 *distance, RZ_NULLABLE double *similarity) {
rz_return_val_if_fail(a && b, false);
const ut32 length = RZ_MAX(la, lb);
const ut8 *ea = a + la, *eb = b + lb, *t;
ut32 *d, i, j;
for (; a < ea && b < eb && *a == *b; a++, b++) {
}
for (; a < ea && b < eb && ea[-1] == eb[-1]; ea--, eb--) {
}
la = ea - a;
lb = eb - b;
if (la < lb) {
i = la;
la = lb;
lb = i;
t = a;
a = b;
b = t;
}
if (sizeof(ut32) > SIZE_MAX / (lb + 1) || !(d = malloc((lb + 1) * sizeof(ut32)))) {
return false;
}
for (i = 0; i <= lb; i++) {
d[i] = i;
}
for (i = 0; i < la; i++) {
ut32 ul = d[0];
d[0] = i + 1;
for (j = 0; j < lb; j++) {
ut32 u = d[j + 1];
d[j + 1] = a[i] == b[j] ? ul : RZ_MIN(ul, RZ_MIN(d[j], u)) + 1;
ul = u;
}
}
if (distance) {
*distance = d[lb];
}
if (similarity) {
*similarity = length ? 1.0 - (double)d[lb] / length : 1.0;
}
free(d);
return true;
}
rizin-0.7.4/librz/diff/bytes_diff.c 0000664 0001750 0001750 00000001670 14731035230 016535 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 RizinOrg
// SPDX-FileCopyrightText: 2021 deroad
// SPDX-License-Identifier: LGPL-3.0-only
/* Helpers for handling bytes */
#define DIFF_IS_BYTES_METHOD(x) (x.elem_at == methods_bytes.elem_at)
static const void *byte_elem_at(const ut8 *array, ut32 index) {
return &array[index];
}
static int byte_compare(const ut8 *a_elem, const ut8 *b_elem) {
return ((int)b_elem[0]) - ((int)a_elem[0]);
}
static ut32 byte_hash(const char *elem) {
return elem[0];
}
static void byte_stringify(const ut8 *a_elem, RzStrBuf *sb) {
rz_strbuf_setf(sb, "%02x", *a_elem);
}
static const MethodsInternal methods_bytes = {
.elem_at /* */ = (RzDiffMethodElemAt)byte_elem_at,
.elem_hash /**/ = (RzDiffMethodElemHash)byte_hash,
.compare /* */ = (RzDiffMethodCompare)byte_compare,
.stringify /**/ = (RzDiffMethodStringify)byte_stringify,
.ignore /* */ = fake_ignore,
.free /* */ = NULL,
};
rizin-0.7.4/librz/diff/README.md 0000664 0001750 0001750 00000000000 14731035230 015514 0 ustar sophie sophie rizin-0.7.4/librz/diff/diff.c 0000664 0001750 0001750 00000056215 14731035230 015334 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 RizinOrg
// SPDX-FileCopyrightText: 2021 deroad
// SPDX-License-Identifier: LGPL-3.0-only
/** \file diff.c
* Ratcliff/Obershelp Pattern Recognition
* Ratcliff/Obershelp Pattern Recognition algorithm applied to generic data.
*
* The code for diffing is quite simple, given 2 arrays containing
* data, you calculate the longest sequences of data that matches
* between the two inputs; to do that you need to create a map in
* which you will store all the hits found within an array:
* - as key, each single element of one of the arrays.
* - as value, a list of all the locations of which each element
* appears within the array itself.
*
* Once this map is created, you will need to find the longest
* subsequence that can be found in both arrays by using the hit-map.
* then you remove that subsequence from the area of search, and
* search again for the 2nd longest subsequence (excluding the area
* of the first subsequence).
* Then you keep doing this, till all areas and longest matches have
* been found.
*
* Now that you know all the matching areas, you can generate a series
* of steps/operations which can transform the first array into the
* second one, by removing the non matching areas in the 1st array
* and inserting the missing areas from the 2nd array.
* Example:
* array_a = [A,B,C,D,E,F,G,H,I]
* array_b = [Y,Z,B,C,D,L,Z,N,H,I]
*
* 1: create map of hits and their positions:
* - hit_map(array_b) = {
* B: [2]
* C: [3]
* D: [4]
* H: [8]
* I: [9]
* L: [5]
* N: [7]
* Y: [0]
* Z: [1,6]
* }
*
* 2: find all matching areas using the hit-map:
* - match_0 = [B,C,D] from array_a[1] to array_a[3] and from array_b[3] to array_b[4]
* - match_1 = [H,I] from array_a[1] to array_a[8] and from array_b[8] to array_b[9]
* 3: create the steps to convert array_a in array_b
* - remove [A] at 0
* - insert [Y,Z] at 0
* - keep [B,C,D] at 1
* - remove [E,F,G] at 4
* - insert [L,Z,N] at 4
* - keep [H,I] at 8
*/
#include
#include
/**/
#include
#include
#define NUM2PTR(x) ((void *)(intptr_t)(x))
#define PTR2NUM(x) ((intptr_t)(void *)(x))
RZ_LIB_VERSION(rz_diff);
typedef struct block_t {
ut32 a_low;
ut32 a_hi;
ut32 b_low;
ut32 b_hi;
} Block;
typedef void (*RzDiffMethodFree)(const void *array);
typedef struct methods_internal_t {
RzDiffMethodElemAt elem_at;
RzDiffMethodElemHash elem_hash;
RzDiffMethodCompare compare;
RzDiffMethodIgnore ignore;
RzDiffMethodStringify stringify;
RzDiffMethodFree free;
} MethodsInternal;
struct rz_diff_t {
const void *a;
const void *b;
ut32 a_size;
ut32 b_size;
HtPP *b_hits;
MethodsInternal methods;
};
/**
* \brief Calculates the hash of any given data
*
* Calculates the hash of any given data with a user defined size.
* */
RZ_API ut32 rz_diff_hash_data(RZ_NULLABLE const ut8 *buffer, ut32 size) {
ut32 h = 5381;
if (!buffer || !size) {
return h;
}
for (ut32 i = 0; i < size; ++i) {
h = (h + (h << 5)) ^ buffer[i];
}
return h;
}
static ut32 default_ksize(const void *a) {
return sizeof(ut32);
}
static bool fake_ignore(const void *value) {
return false;
}
#include "bytes_diff.c"
#include "lines_diff.c"
#include "unified_diff.c"
static bool set_a(RzDiff *diff, const void *a, ut32 a_size) {
rz_return_val_if_fail(a, false);
diff->a = a;
diff->a_size = a_size;
return true;
}
static void free_hits(HtPPKv *kv) {
rz_list_free(kv->value);
}
static bool set_b(RzDiff *diff, const void *b, ut32 b_size) {
rz_return_val_if_fail(b && diff->methods.elem_at && diff->methods.elem_hash && diff->methods.compare && diff->methods.ignore, false);
diff->b = b;
diff->b_size = b_size;
RzList *list = NULL;
RzDiffMethodElemAt elem_at = diff->methods.elem_at;
RzDiffMethodIgnore ignore = diff->methods.ignore;
/* we need to generate the hits list for B */
ht_pp_free(diff->b_hits);
diff->b_hits = ht_pp_new(NULL, free_hits, NULL);
diff->b_hits->opt.cmp /* */ = diff->methods.compare;
diff->b_hits->opt.calcsizeK /**/ = default_ksize;
diff->b_hits->opt.dupkey /* */ = NULL; // avoid to duplicate key
diff->b_hits->opt.hashfn /* */ = diff->methods.elem_hash;
for (ut64 i = 0; i < diff->b_size; ++i) {
const void *elem = elem_at(diff->b, i);
if (ignore && ignore(elem)) {
continue;
}
list = ht_pp_find(diff->b_hits, elem, NULL);
if (!list) {
list = rz_list_newf(NULL);
if (!list) {
RZ_LOG_ERROR("rz_diff_set_b: cannot allocate list\n");
return false;
}
ht_pp_insert(diff->b_hits, elem, list);
}
if (!rz_list_append(list, NUM2PTR(i))) {
RZ_LOG_ERROR("rz_diff_set_b: cannot append index to list\n");
return false;
}
}
return true;
}
/**
* \brief Returns the structure needed to diff buffers of ut8
*
* Allocates the internal structure needed to diff buffers by
* using the methods defined in methods_bytes.
* Allows to define an callback function to ignore bytes.
* */
RZ_API RZ_OWN RzDiff *rz_diff_bytes_new(RZ_BORROW const ut8 *a, ut32 a_size, RZ_BORROW const ut8 *b, ut32 b_size, RZ_NULLABLE RzDiffIgnoreByte ignore) {
rz_return_val_if_fail(a && b, NULL);
RzDiff *diff = RZ_NEW0(RzDiff);
if (!diff) {
return NULL;
}
diff->methods = methods_bytes;
if (ignore) {
diff->methods.ignore = (RzDiffMethodIgnore)ignore;
}
if (!set_a(diff, a, a_size)) {
rz_diff_free(diff);
return NULL;
}
if (!set_b(diff, b, b_size)) {
rz_diff_free(diff);
return NULL;
}
return diff;
}
/**
* \brief Returns the structure needed to diff lines
*
* Allocates the internal structure needed to diff strings with new lines
* using the methods defined in methods_lines.
* Allows to define an callback function to ignore lines.
* */
RZ_API RZ_OWN RzDiff *rz_diff_lines_new(RZ_BORROW const char *a, RZ_BORROW const char *b, RZ_NULLABLE RzDiffIgnoreLine ignore) {
rz_return_val_if_fail(a && b, NULL);
RzDiff *diff = RZ_NEW0(RzDiff);
if (!diff) {
return NULL;
}
RzList *a_lines = tokenize_lines(a);
RzList *b_lines = tokenize_lines(b);
if (!a_lines || !b_lines) {
rz_list_free(a_lines);
rz_list_free(b_lines);
free(diff);
return NULL;
}
diff->methods = methods_lines;
if (ignore) {
diff->methods.ignore = (RzDiffMethodIgnore)ignore;
}
if (!set_a(diff, a_lines, rz_list_length(a_lines))) {
rz_diff_free(diff);
return NULL;
}
if (!set_b(diff, b_lines, rz_list_length(b_lines))) {
rz_diff_free(diff);
return NULL;
}
return diff;
}
/**
* \brief Returns the structure needed to diff arrays of user defined types
*
* Allocates the internal structure needed to diff any user defined array
* of any types by using the methods provided by the user calling this C api.
* */
RZ_API RZ_OWN RzDiff *rz_diff_generic_new(RZ_BORROW const void *a, ut32 a_size, RZ_BORROW const void *b, ut32 b_size, RZ_NONNULL RzDiffMethods *methods) {
rz_return_val_if_fail(a && b && methods && methods->elem_at && methods->elem_hash && methods->compare && methods->stringify, NULL);
RzDiff *diff = RZ_NEW0(RzDiff);
if (!diff) {
return NULL;
}
diff->methods.free = NULL;
diff->methods.elem_at = methods->elem_at;
diff->methods.elem_hash = methods->elem_hash;
diff->methods.compare = methods->compare;
diff->methods.stringify = methods->stringify;
if (methods->ignore) {
diff->methods.ignore = methods->ignore;
} else {
diff->methods.ignore = fake_ignore;
}
if (!set_a(diff, a, a_size)) {
rz_diff_free(diff);
return NULL;
}
if (!set_b(diff, b, b_size)) {
rz_diff_free(diff);
return NULL;
}
return diff;
}
/**
* \brief frees the diff structure
*
* frees any internal structure and the diff structure.
* */
RZ_API void rz_diff_free(RZ_NULLABLE RzDiff *diff) {
if (!diff) {
return;
}
if (diff->methods.free) {
diff->methods.free(diff->a);
diff->methods.free(diff->b);
}
ht_pp_free(diff->b_hits);
free(diff);
}
/**
* \brief returns the pointer of the A array that passed to rz_diff_XXX_new()
*
* returns the pointer of the A array that passed to rz_diff_XXX_new()
* */
RZ_API RZ_BORROW const void *rz_diff_get_a(RZ_NONNULL RzDiff *diff) {
rz_return_val_if_fail(diff, NULL);
return diff->a;
}
/**
* \brief returns the pointer of the B array that passed to rz_diff_XXX_new()
*
* returns the pointer of the B array that passed to rz_diff_XXX_new()
* */
RZ_API RZ_BORROW const void *rz_diff_get_b(RZ_NONNULL RzDiff *diff) {
rz_return_val_if_fail(diff, NULL);
return diff->b;
}
static inline bool stack_append_block(RzList /**/ *stack, ut32 a_low, ut32 a_hi, ut32 b_low, ut32 b_hi) {
Block *block = RZ_NEW0(Block);
if (!block) {
return false;
}
block->a_low = a_low;
block->a_hi = a_hi;
block->b_low = b_low;
block->b_hi = b_hi;
if (!rz_list_append(stack, block)) {
free(block);
return false;
}
return true;
}
static RzDiffMatch *match_new(ut32 a, ut32 b, ut32 size) {
RzDiffMatch *match = RZ_NEW0(RzDiffMatch);
if (!match) {
return NULL;
}
match->a = a;
match->b = b;
match->size = size;
return match;
}
static RzDiffMatch *find_longest_match(RzDiff *diff, Block *block) {
rz_return_val_if_fail(diff && diff->methods.elem_at && diff->methods.compare && diff->methods.ignore, false);
RzList *list = NULL;
RzListIter *it = NULL;
RzDiffMatch *match = NULL;
HtUU *tmp = NULL;
HtUU *len_map = NULL;
void *pnum = NULL;
const ut8 *a = diff->a;
const ut8 *b = diff->b;
const void *elem_a = NULL;
const void *elem_b = NULL;
RzDiffMethodIgnore ignore = diff->methods.ignore;
RzDiffMethodElemAt elem_at = diff->methods.elem_at;
RzDiffMethodCompare compare = diff->methods.compare;
ut32 a_low = block->a_low;
ut32 a_hi = block->a_hi;
ut32 b_low = block->b_low;
ut32 b_hi = block->b_hi;
ut32 hit_a = a_low;
ut32 hit_b = b_low;
ut32 hit_size = 0;
len_map = ht_uu_new0();
if (!len_map) {
RZ_LOG_ERROR("find_longest_match: cannot allocate len_map\n");
goto find_longest_match_fail;
}
for (ut32 a_pos = a_low; a_pos < a_hi; ++a_pos) {
elem_a = elem_at(a, a_pos);
tmp = ht_uu_new0();
if (!tmp) {
RZ_LOG_ERROR("find_longest_match: cannot allocate tmp\n");
goto find_longest_match_fail;
}
list = ht_pp_find(diff->b_hits, elem_a, NULL);
rz_list_foreach (list, it, pnum) {
ut64 b_pos = PTR2NUM(pnum);
if (b_pos < b_low) {
continue;
} else if (b_pos >= b_hi) {
break;
}
ut32 len = ht_uu_find(len_map, b_pos - 1, NULL) + 1;
ht_uu_insert(tmp, b_pos, len);
if (len > hit_size) {
hit_a = a_pos - len + 1;
hit_b = b_pos - len + 1;
hit_size = len;
}
}
ht_uu_free(len_map);
len_map = tmp;
tmp = NULL;
}
// Now let's handle the without the ignored chars.
while (hit_a > a_low && hit_b > b_low) {
elem_a = elem_at(a, hit_a - 1);
elem_b = elem_at(b, hit_b - 1);
if (ignore(elem_b) || compare(elem_a, elem_b)) {
break;
}
hit_a--;
hit_b--;
hit_size++;
}
while (hit_a + hit_size < a_hi && hit_b + hit_size < b_hi) {
elem_a = elem_at(a, hit_a + hit_size);
elem_b = elem_at(b, hit_b + hit_size);
if (ignore(elem_b) || compare(elem_a, elem_b)) {
break;
}
hit_size++;
}
// Now let's handle the ignored chars.
while (hit_a > a_low && hit_b > b_low) {
elem_a = elem_at(a, hit_a - 1);
elem_b = elem_at(b, hit_b - 1);
if (!ignore(elem_b) || compare(elem_a, elem_b)) {
break;
}
hit_a--;
hit_b--;
hit_size++;
}
while (hit_a + hit_size < a_hi && hit_b + hit_size < b_hi) {
elem_a = elem_at(a, hit_a + hit_size);
elem_b = elem_at(b, hit_b + hit_size);
if (!ignore(elem_b) || compare(elem_a, elem_b)) {
break;
}
hit_size++;
}
match = match_new(hit_a, hit_b, hit_size);
if (!match) {
RZ_LOG_ERROR("find_longest_match: cannot allocate RzDiffMatch\n");
goto find_longest_match_fail;
}
ht_uu_free(len_map);
return match;
find_longest_match_fail:
ht_uu_free(tmp);
ht_uu_free(len_map);
return NULL;
}
static int cmp_matches(RzDiffMatch *m0, RzDiffMatch *m1, void *user) {
if (m0->a > m1->a) {
return 1;
} else if (m0->a < m1->a) {
return -1;
} else if (m0->b > m1->b) {
return 1;
} else if (m0->b < m1->b) {
return -1;
} else if (m0->size > m1->size) {
return 1;
} else if (m0->size < m1->size) {
return -1;
}
return 0;
}
/**
* \brief generates a list of matching blocks
*
* Generates a list of matching blocks that are found in both inputs.
* If non are found it returns a match result with size of 0
* */
RZ_API RZ_OWN RzList /**/ *rz_diff_matches_new(RZ_NONNULL RzDiff *diff) {
rz_return_val_if_fail(diff, NULL);
RzList *stack = NULL;
RzList *matches = NULL;
RzList *non_adjacent = NULL;
RzListIter *it = NULL;
Block *block = NULL;
RzDiffMatch *match = NULL;
ut32 adj_a = 0, adj_b = 0, adj_size = 0;
matches = rz_list_newf((RzListFree)free);
if (!matches) {
RZ_LOG_ERROR("rz_diff_matches_new: cannot allocate matches\n");
goto rz_diff_matches_new_fail;
}
non_adjacent = rz_list_newf((RzListFree)free);
if (!matches) {
RZ_LOG_ERROR("rz_diff_matches_new: cannot allocate non_adjacent\n");
goto rz_diff_matches_new_fail;
}
stack = rz_list_newf((RzListFree)free);
if (!stack) {
RZ_LOG_ERROR("rz_diff_matches_new: cannot allocate stack\n");
goto rz_diff_matches_new_fail;
}
if (!stack_append_block(stack, 0, diff->a_size, 0, diff->b_size)) {
RZ_LOG_ERROR("rz_diff_matches_new: cannot append initial block "
"into stack\n");
goto rz_diff_matches_new_fail;
}
while (rz_list_length(stack) > 0) {
block = (Block *)rz_list_pop(stack);
match = find_longest_match(diff, block);
if (!match) {
continue;
}
if (match->size > 0) {
if (!rz_list_append(matches, match)) {
RZ_LOG_ERROR("rz_diff_matches_new: cannot append match into matches\n");
free(match);
goto rz_diff_matches_new_fail;
}
if (block->a_low < match->a && block->b_low < match->b) {
if (!stack_append_block(stack, block->a_low, match->a, block->b_low, match->b)) {
RZ_LOG_ERROR("rz_diff_matches_new: cannot append low block into stack\n");
goto rz_diff_matches_new_fail;
}
}
if (match->a + match->size < block->a_hi && match->b + match->size < block->b_hi) {
if (!stack_append_block(stack, match->a + match->size, block->a_hi, match->b + match->size, block->b_hi)) {
RZ_LOG_ERROR("rz_diff_matches_new: cannot append high block into stack\n");
goto rz_diff_matches_new_fail;
}
}
} else {
free(match);
}
free(block);
}
rz_list_sort(matches, (RzListComparator)cmp_matches, NULL);
adj_a = 0;
adj_b = 0;
adj_size = 0;
rz_list_foreach (matches, it, match) {
if ((adj_a + adj_size) == match->a && (adj_b + adj_size) == match->b) {
adj_size += match->size;
} else {
RzDiffMatch *m = adj_size ? match_new(adj_a, adj_b, adj_size) : NULL;
if (adj_size && (!m || !rz_list_append(non_adjacent, m))) {
RZ_LOG_ERROR("rz_diff_matches_new: cannot append match into non_adjacent\n");
free(m);
goto rz_diff_matches_new_fail;
}
adj_a = match->a;
adj_b = match->b;
adj_size = match->size;
}
}
match = adj_size ? match_new(adj_a, adj_b, adj_size) : NULL;
if (adj_size && (!match || !rz_list_append(non_adjacent, match))) {
RZ_LOG_ERROR("rz_diff_matches_new: cannot append match into non_adjacent\n");
free(match);
goto rz_diff_matches_new_fail;
}
match = match_new(diff->a_size, diff->b_size, 0);
if (!match || !rz_list_append(non_adjacent, match)) {
RZ_LOG_ERROR("rz_diff_matches_new: cannot append match into non_adjacent\n");
free(match);
goto rz_diff_matches_new_fail;
}
rz_list_free(matches);
rz_list_free(stack);
return non_adjacent;
rz_diff_matches_new_fail:
rz_list_free(non_adjacent);
rz_list_free(matches);
rz_list_free(stack);
return NULL;
}
static RzDiffOp *opcode_new(RzDiffOpType type, st32 a_beg, st32 a_end, st32 b_beg, st32 b_end) {
RzDiffOp *op = RZ_NEW0(RzDiffOp);
if (!op) {
return NULL;
}
op->type = type;
op->a_beg = a_beg;
op->a_end = a_end;
op->b_beg = b_beg;
op->b_end = b_end;
return op;
}
static void opcode_set(RzDiffOp *op, RzDiffOpType type, st32 a_beg, st32 a_end, st32 b_beg, st32 b_end) {
op->type = type;
op->a_beg = a_beg;
op->a_end = a_end;
op->b_beg = b_beg;
op->b_end = b_end;
}
/**
* \brief Generates a list of steps needed to go from A to B
*
* Generates a list of opcodes that are needed to convert A to B.
* */
RZ_API RZ_OWN RzList /**/ *rz_diff_opcodes_new(RZ_NONNULL RzDiff *diff) {
rz_return_val_if_fail(diff, NULL);
ut32 a = 0, b = 0;
RzDiffOpType type = RZ_DIFF_OP_INVALID;
RzDiffOp *op = NULL;
RzDiffMatch *match = NULL;
RzListIter *it = NULL;
RzList *matches = NULL;
RzList *opcodes = NULL;
matches = rz_diff_matches_new(diff);
if (!matches) {
goto rz_diff_opcodes_new_fail;
}
opcodes = rz_list_newf((RzListFree)free);
if (!opcodes) {
RZ_LOG_ERROR("rz_diff_opcodes_new: cannot allocate opcodes\n");
goto rz_diff_opcodes_new_fail;
}
a = 0;
b = 0;
rz_list_foreach (matches, it, match) {
type = RZ_DIFF_OP_INVALID;
if (a < match->a && b < match->b) {
type = RZ_DIFF_OP_REPLACE;
} else if (a < match->a) {
type = RZ_DIFF_OP_DELETE;
} else if (b < match->b) {
type = RZ_DIFF_OP_INSERT;
}
if (type != RZ_DIFF_OP_INVALID) {
op = opcode_new(type, a, match->a, b, match->b);
if (!op) {
RZ_LOG_ERROR("rz_diff_opcodes_new: cannot allocate op\n");
goto rz_diff_opcodes_new_fail;
} else if (!rz_list_append(opcodes, op)) {
RZ_LOG_ERROR("rz_diff_opcodes_new: cannot append op into opcodes\n");
free(op);
goto rz_diff_opcodes_new_fail;
}
}
a = match->a + match->size;
b = match->b + match->size;
if (match->size > 0) {
op = opcode_new(RZ_DIFF_OP_EQUAL, match->a, a, match->b, b);
if (!op) {
RZ_LOG_ERROR("rz_diff_opcodes_new: cannot allocate op\n");
goto rz_diff_opcodes_new_fail;
} else if (!rz_list_append(opcodes, op)) {
RZ_LOG_ERROR("rz_diff_opcodes_new: cannot append op into opcodes\n");
free(op);
goto rz_diff_opcodes_new_fail;
}
}
}
rz_list_free(matches);
return opcodes;
rz_diff_opcodes_new_fail:
rz_list_free(matches);
rz_list_free(opcodes);
return NULL;
}
static void group_op_free(RzList /**/ *ops) {
rz_list_free(ops);
}
/**
* \brief Generates groups of opcodes needed to go from A to B.
*
* Generates groups of opcodes needed to go from A to B, but
* each group will end with N common EQUAL ops (if possible).
* default is 3 equals ops before splitting the group.
* */
RZ_API RZ_OWN RzList /* *>*/ *rz_diff_opcodes_grouped_new(RZ_NONNULL RzDiff *diff, ut32 n_groups) {
rz_return_val_if_fail(diff && n_groups > 1, NULL);
RzDiffOp *op = NULL;
RzListIter *it = NULL;
RzList *group = NULL;
RzList *groups = NULL;
RzList *opcodes = NULL;
st32 a_beg = 0, b_beg = 0, max_groups = 0;
max_groups = n_groups << 1;
groups = rz_list_newf((RzListFree)group_op_free);
if (!groups) {
RZ_LOG_ERROR("rz_diff_opcodes_grouped_new: cannot allocate groups\n");
goto rz_diff_opcodes_grouped_new_fail;
}
opcodes = rz_diff_opcodes_new(diff);
if (!opcodes) {
goto rz_diff_opcodes_grouped_new_fail;
}
if (rz_list_length(opcodes) < 1) {
op = opcode_new(RZ_DIFF_OP_EQUAL, 0, 1, 0, 1);
if (!op) {
RZ_LOG_ERROR("rz_diff_opcodes_grouped_new: cannot allocate op for opcodes\n");
goto rz_diff_opcodes_grouped_new_fail;
} else if (!rz_list_append(opcodes, op)) {
RZ_LOG_ERROR("rz_diff_opcodes_grouped_new: cannot append op into opcodes\n");
free(op);
goto rz_diff_opcodes_grouped_new_fail;
}
}
op = rz_list_first(opcodes);
if (op->type == RZ_DIFF_OP_EQUAL) {
opcode_set(op, op->type, RZ_MAX(op->a_beg, op->a_end - n_groups), op->a_end, RZ_MAX(op->b_beg, op->b_end - n_groups), op->b_end);
}
op = rz_list_last(opcodes);
if (op->type == RZ_DIFF_OP_EQUAL) {
opcode_set(op, op->type, op->a_beg, RZ_MIN(op->a_end, op->a_beg + n_groups), op->b_beg, RZ_MIN(op->b_end, op->b_beg + n_groups));
}
group = rz_list_newf((RzListFree)free);
if (!group) {
RZ_LOG_ERROR("rz_diff_opcodes_grouped_new: cannot allocate group\n");
goto rz_diff_opcodes_grouped_new_fail;
}
rz_list_foreach (opcodes, it, op) {
a_beg = op->a_beg;
b_beg = op->b_beg;
if (op->type == RZ_DIFF_OP_EQUAL && (op->a_end - a_beg) > max_groups) {
// append the last op of the group, append group to groups and create a new group.
RzDiffOp *op2 = opcode_new(RZ_DIFF_OP_EQUAL, a_beg, RZ_MIN(op->a_end, a_beg + n_groups), b_beg, RZ_MIN(op->b_end, b_beg + n_groups));
if (!op2) {
RZ_LOG_ERROR("rz_diff_opcodes_grouped_new: cannot allocate op for group\n");
goto rz_diff_opcodes_grouped_new_fail;
} else if (!rz_list_append(group, op2)) {
RZ_LOG_ERROR("rz_diff_opcodes_grouped_new: cannot append op into group\n");
free(op2);
goto rz_diff_opcodes_grouped_new_fail;
} else if (!rz_list_append(groups, group)) {
RZ_LOG_ERROR("rz_diff_opcodes_grouped_new: cannot append group into groups\n");
rz_list_free(group);
goto rz_diff_opcodes_grouped_new_fail;
}
group = rz_list_newf((RzListFree)free);
if (!group) {
RZ_LOG_ERROR("rz_diff_opcodes_grouped_new: cannot allocate new group\n");
goto rz_diff_opcodes_grouped_new_fail;
}
a_beg = RZ_MAX(a_beg, op->a_end - n_groups);
b_beg = RZ_MAX(b_beg, op->b_end - n_groups);
}
op = opcode_new(op->type, a_beg, op->a_end, b_beg, op->b_end);
if (!op) {
rz_list_free(group);
RZ_LOG_ERROR("rz_diff_opcodes_grouped_new: cannot allocate op for group\n");
goto rz_diff_opcodes_grouped_new_fail;
} else if (!rz_list_append(group, op)) {
RZ_LOG_ERROR("rz_diff_opcodes_grouped_new: cannot append op into group\n");
free(op);
rz_list_free(group);
goto rz_diff_opcodes_grouped_new_fail;
}
}
op = rz_list_first(opcodes);
if (!(rz_list_length(opcodes) == 1 && op->type == RZ_DIFF_OP_EQUAL)) {
if (!rz_list_append(groups, group)) {
RZ_LOG_ERROR("rz_diff_opcodes_grouped_new: cannot append group into groups\n");
rz_list_free(group);
goto rz_diff_opcodes_grouped_new_fail;
}
} else {
rz_list_free(group);
}
rz_list_free(opcodes);
return groups;
rz_diff_opcodes_grouped_new_fail:
rz_list_free(groups);
rz_list_free(opcodes);
return NULL;
}
/**
* \brief Calculates the similarity ratio between A and B.
*
* Calculates the similarity ratio between A and B.
* Returns a number between 0 and 1; closer to 1 the result
* is more similar/identical the 2 arrays are.
* */
RZ_API bool rz_diff_ratio(RZ_NONNULL RzDiff *diff, RZ_NONNULL double *result) {
rz_return_val_if_fail(diff && result, false);
RzList *matches = NULL;
RzDiffMatch *match = NULL;
RzListIter *it = NULL;
ut32 hits = 0;
matches = rz_diff_matches_new(diff);
if (!matches) {
return false;
}
rz_list_foreach (matches, it, match) {
hits += match->size;
}
rz_list_free(matches);
/* simple cast to avoid math issues */
double d_hits = hits;
double d_size = diff->a_size + diff->b_size;
if (d_size > 0.0) {
*result = (2.0 * d_hits) / d_size;
} else {
*result = 1.0;
}
return true;
}
/**
* \brief Calculates the size ratio between A and B.
*
* Works like the rz_diff_ratio, but this checks only
* how similar are the sizes between the two arrays.
* Returns a number between 0 and 1, like above.
* */
RZ_API bool rz_diff_sizes_ratio(RZ_NONNULL RzDiff *diff, RZ_NONNULL double *result) {
rz_return_val_if_fail(diff && result, false);
/* simple cast to avoid math issues */
double d_hits = RZ_MIN(diff->a_size, diff->b_size);
double d_size = diff->a_size + diff->b_size;
if (d_size > 0.0) {
*result = (2.0 * d_hits) / d_size;
} else {
*result = 1.0;
}
return true;
}
rizin-0.7.4/librz/meson.build 0000664 0001750 0001750 00000005513 14731035230 015505 0 ustar sophie sophie
modules = {} # every rizin module subdir registers in here
subdir('include')
subdir('util')
subdir('demangler')
subdir('socket')
subdir('hash')
subdir('crypto')
subdir('cons')
subdir('diff')
subdir('io')
subdir('bp')
subdir('syscall')
subdir('search')
subdir('magic')
subdir('flag')
subdir('reg')
subdir('type')
subdir('bin')
subdir('config')
subdir('parse')
subdir('lang')
subdir('asm')
subdir('il')
subdir('analysis')
subdir('sign')
subdir('egg')
subdir('debug')
subdir('core')
subdir('main')
conf_data = configuration_data()
foreach module_name, module : modules
include_subdirs = ['librz']
if 'include_subdirs_extra' in module
include_subdirs += module['include_subdirs_extra']
endif
# pkg-config
pkgconfig_vars = []
if 'plugins' in module
pkgconfig_vars += ['plugindir=@0@'.format(rizin_plugins)]
endif
pkgconfig_vars += ['datdir=@0@'.format(rizin_datdir_rz)]
pkgconfig_mod.generate(module['target'],
subdirs: include_subdirs,
version: rizin_version,
name: module_name,
filebase: module_name,
requires: module['dependencies'],
description: 'rizin foundation libraries',
variables: pkgconfig_vars,
)
# cmake
if not is_static_libs_only
conf = configuration_data()
conf.set('RZ_VERSION', rizin_version)
conf.set('RIZIN_MODULE', module['target'].name())
conf.set('RIZIN_MODULE_DEPS', ' '.join(module['dependencies']))
conf.set('PACKAGE_RELATIVE_PATH', cmake_package_relative_path)
conf.set('INSTALL_INCDIR', rizin_incdir)
conf.set('INSTALL_LIBDIR', rizin_libdir)
conf.set('INSTALL_PLUGDIR', rizin_plugins)
conf.set('rizin_libname', module['target'].name())
# meson's cmake module is not used on purpose due to:
# https://todo.sr.ht/~lattis/muon/24
# https://github.com/mesonbuild/meson/issues/9702
configure_file(
output: conf.get('rizin_libname') + 'Config.cmake',
input: 'RzModulesConfig.cmake.in',
install_dir: rizin_cmakedir / conf.get('rizin_libname'),
configuration: conf,
)
endif
# plugins
if 'plugins' in module
foreach plugin : module['plugins']
l = []
foreach p : plugin.get('list')
l += ['&' + plugin.get('base_cname') + p]
endforeach
conf_data.set(plugin.get('conf_name'), ', '.join(l))
endforeach
endif
endforeach
config_h = configure_file(
input: 'config.h.in',
output: 'config.h',
configuration: conf_data
)
if not is_static_libs_only
conf = configuration_data()
conf.set('RZ_VERSION', rizin_version)
conf.set('INSTALL_PLUGDIR', rizin_plugins)
# meson's cmake module is not used on purpose due to:
# https://todo.sr.ht/~lattis/muon/24
# https://github.com/mesonbuild/meson/issues/9702
configure_file(
output: 'RizinConfig.cmake',
input: 'RizinConfig.cmake.in',
install_dir: rizin_cmakedir / 'Rizin',
configuration: conf,
)
endif
rizin-0.7.4/librz/RzModulesConfig.cmake.in 0000664 0001750 0001750 00000006220 14731035230 020020 0 ustar sophie sophie ################################################################################
#
# This module provides the following imported targets, if found:
#
# @RIZIN_MODULE@::@RIZIN_MODULE@
#
# This file is intended to be consumed by clients who wish to use @rizin_libname@ from CMake.
# The recommended way to use find this module is using `find_package(Rizin COMPONENTS ...)`.
#
# Provides the following variables
# @RIZIN_MODULE@_FOUND - Flag for indicating that @RIZIN_MODULE@ package has been found
# @RIZIN_MODULE@_VERSION - Version of @RIZIN_MODULE@
# @RIZIN_MODULE@_INCLUDE_DIRS - Directories to include
# @RIZIN_MODULE@_LIBRARY - Path to the single library that this module represents, without dependencies
# @RIZIN_MODULE@_LIBRARIES - Libraries to link
# @RIZIN_MODULE@_LIBRARY_DIRS - Library directories to search for link libraries
# @RIZIN_MODULE@_PLUGINDIR - Directory where plugins are placed, without the prefix part
#
################################################################################
set(RIZIN_MODULE_PREFIXED @RIZIN_MODULE@)
set(@RIZIN_MODULE@_VERSION @RZ_VERSION@)
get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/@PACKAGE_RELATIVE_PATH@" ABSOLUTE)
macro(set_and_check _var _file)
set(${_var} "${_file}")
if(NOT EXISTS "${_file}")
message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
endif()
endmacro()
set(@RIZIN_MODULE@_INCLUDE_DIRS "${PACKAGE_PREFIX_DIR}/@INSTALL_INCDIR@" "${PACKAGE_PREFIX_DIR}/@INSTALL_INCDIR@/sdb")
set_and_check(@RIZIN_MODULE@_LIBRARY_DIRS "${PACKAGE_PREFIX_DIR}/@INSTALL_LIBDIR@")
find_library(@RIZIN_MODULE@_LIBRARY NAMES @RIZIN_MODULE@ HINTS "${@RIZIN_MODULE@_LIBRARY_DIRS}" NO_DEFAULT_PATH REQUIRED)
set(@RIZIN_MODULE@_LIBRARIES "${@RIZIN_MODULE@_LIBRARY}")
set(_@RIZIN_MODULE@_DEPENDENCIES @RIZIN_MODULE_DEPS@)
set(@RIZIN_MODULE@_PLUGINDIR @INSTALL_PLUGDIR@)
include(CMakeFindDependencyMacro)
get_filename_component(_rizin_cmake_path "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE)
set(_@RIZIN_MODULE@_DEPENDENCY_TARGETS)
foreach(_module_dep ${_@RIZIN_MODULE@_DEPENDENCIES})
if (NOT ${_module_dep}_FOUND)
find_dependency(${_module_dep} PATHS ${_rizin_cmake_path} NO_DEFAULT_PATH)
endif()
if (NOT ${_module_dep}_FOUND)
set(@RIZIN_MODULE@_FOUND False)
return()
endif()
list(APPEND @RIZIN_MODULE@_INCLUDE_DIRS "${${_module_dep}_INCLUDE_DIRS}")
list(APPEND @RIZIN_MODULE@_LIBRARIES "${${_module_dep}_LIBRARIES}")
list(APPEND _@RIZIN_MODULE@_DEPENDENCY_TARGETS "${_module_dep}::${_module_dep}")
endforeach()
list(REMOVE_DUPLICATES @RIZIN_MODULE@_INCLUDE_DIRS)
list(REMOVE_DUPLICATES @RIZIN_MODULE@_LIBRARIES)
if(NOT TARGET @RIZIN_MODULE@::@RIZIN_MODULE@)
add_library(@RIZIN_MODULE@::@RIZIN_MODULE@ SHARED IMPORTED)
target_link_libraries(@RIZIN_MODULE@::@RIZIN_MODULE@ INTERFACE ${_@RIZIN_MODULE@_DEPENDENCY_TARGETS})
set_target_properties(@RIZIN_MODULE@::@RIZIN_MODULE@ PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${@RIZIN_MODULE@_INCLUDE_DIRS}")
set_target_properties(@RIZIN_MODULE@::@RIZIN_MODULE@ PROPERTIES
IMPORTED_LOCATION "${@RIZIN_MODULE@_LIBRARY}")
endif()
set(@RIZIN_MODULE@_TARGET @RIZIN_MODULE@::@RIZIN_MODULE@)
rizin-0.7.4/librz/parse/ 0000775 0001750 0001750 00000000000 14731035230 014451 5 ustar sophie sophie rizin-0.7.4/librz/parse/meson.build 0000664 0001750 0001750 00000003247 14731035230 016621 0 ustar sophie sophie parse_plugins_list = [
'6502_pseudo',
'arm_pseudo',
'att2intel',
'avr_pseudo',
'chip8_pseudo',
'tms320_pseudo',
'dalvik_pseudo',
'm68k_pseudo',
'mips_pseudo',
'ppc_pseudo',
'v850_pseudo',
'wasm_pseudo',
'x86_pseudo',
]
if get_option('use_gpl')
parse_plugins_list += [
'sh_pseudo',
'riscv_pseudo',
'z80_pseudo'
]
endif
parse_plugins = {
'conf_name': 'plugins_parse',
'base_cname': 'rz_parse_plugin_',
'list': parse_plugins_list,
}
rz_parse_sources = [
'filter.c',
'parse.c',
'p/parse_6502_pseudo.c',
'p/parse_arm_pseudo.c',
'p/parse_att2intel.c',
'p/parse_avr_pseudo.c',
'p/parse_chip8_pseudo.c',
'p/parse_dalvik_pseudo.c',
'p/parse_m68k_pseudo.c',
'p/parse_mips_pseudo.c',
'p/parse_ppc_pseudo.c',
'p/parse_sh_pseudo.c',
'p/parse_tms320_pseudo.c',
'p/parse_v850_pseudo.c',
'p/parse_wasm_pseudo.c',
'p/parse_x86_pseudo.c',
'p/parse_riscv_pseudo.c',
'p/parse_z80_pseudo.c'
]
rz_parse = library('rz_parse', rz_parse_sources,
include_directories: platform_inc,
dependencies: [
rz_util_dep,
rz_flag_dep,
rz_syscall_dep,
rz_reg_dep,
rz_cons_dep,
],
install: true,
implicit_include_directories: false,
install_rpath: rpath_lib,
soversion: rizin_libversion,
version: rizin_version,
name_suffix: lib_name_suffix,
name_prefix: lib_name_prefix,
)
rz_parse_dep = declare_dependency(link_with: rz_parse,
include_directories: platform_inc)
meson.override_dependency('rz_parse', rz_parse_dep)
modules += { 'rz_parse': {
'target': rz_parse,
'dependencies': ['rz_util', 'rz_flag', 'rz_syscall', 'rz_reg', 'rz_cons'],
'plugins': [parse_plugins]
}}
rizin-0.7.4/librz/parse/p/ 0000775 0001750 0001750 00000000000 14731035230 014710 5 ustar sophie sophie rizin-0.7.4/librz/parse/p/parse_tms320_pseudo.c 0000664 0001750 0001750 00000012011 14731035230 020650 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 deroad
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
// https://www.ti.com/lit/ug/spru732j/spru732j.pdf
#include "parse_common.c"
static RzList /**/ *tms320_tokenize(const char *assembly, size_t length);
static const RzPseudoGrammar tms320_lexicon[] = {
RZ_PSEUDO_DEFINE_GRAMMAR("add", "3 = 1 + 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("addab", "3 = 1 + 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("addah", "3 = 1 + 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("addaw", "3 = 1 + 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("addk", "2 += 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("addu", "3 = 1 + 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("addw", "3 = 1 + 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("andn", "3 = 1 ~ 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("avg2", "3 = 1 avg 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("b", "goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("band", "3 = 1 & 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("clr", "4 = 2 .bitclear 1 .. 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmpeq", "3 = 1 == 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmpge", "3 = 1 >= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmpgtu", "3 = 1 > 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmplt", "3 = 1 < 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("ext", "4 = 2 ext 1 .. 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("extu", "4 = 2 ext 1 .. 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldb", "2 = (byte) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldbu", "2 = (byte) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("lddw", "2 = (word) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldh", "2 = (half) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldhu", "2 = (half) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldndw", "2 = 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldnw", "2 = 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldw", "2 = (word) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("max2", "3 = max(1, 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpy", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpy2", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyh", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyhi", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyhir", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyhl", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyhl", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyhlu", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyhslu", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyhsu", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyhu", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyhul", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyhuls", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyhus", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpylh", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyli", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpylir", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyluhs", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpysu", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyu", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mpyu4", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mv", "2 = 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("mvk", "2 = 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("mvklh", "2 = (half) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("nop", ""),
RZ_PSEUDO_DEFINE_GRAMMAR("or", "3 = 2 | 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("pack2", "3 = 1 pack 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("reti", "return"),
RZ_PSEUDO_DEFINE_GRAMMAR("sadd", "3 = 1 + 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sadd2", "3 = 1 + 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("set", "4 = 2 .bitset 1 .. 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("shl", "3 = (2 & #0xffffff) << 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("shlmb", "3 = << 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("shr", "3 = (2 & #0xffffff) << 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("smpy", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("smpy", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("smpyh", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("smpyhl", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("smpylh", "3 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("ssub", "3 = 1 - 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("stb", "2 = (byte) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("stdw", "2 = (half) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sth", "2 = (half) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("stndw", "2 = (half) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("stnw", "2 = (word) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("stw", "2 = (word) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub", "3 = 1 - 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub2", "3 = 1 - 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("subab", "3 = 1 - 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("subu", "3 = 1 - 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("zero", "1 = 0"),
};
static const RzPseudoConfig tms320_config = RZ_PSEUDO_DEFINE_CONFIG_ONLY_LEXICON(tms320_lexicon, 5, tms320_tokenize);
RzList /**/ *tms320_tokenize(const char *assembly, size_t length) {
char *buf = NULL, *sp = NULL;
RzList *tokens = NULL;
buf = rz_str_ndup(assembly, length);
if (!buf) {
return NULL;
}
sp = strchr(buf, ' ');
if (sp) {
*sp = ',';
}
tokens = rz_str_split_duplist(buf, ",", true);
free(buf);
return tokens;
}
static bool parse(RzParse *parse, const char *assembly, RzStrBuf *sb) {
return rz_pseudo_convert(&tms320_config, assembly, sb);
}
RzParsePlugin rz_parse_plugin_tms320_pseudo = {
.name = "tms320.pseudo",
.desc = "tms320 pseudo syntax",
.parse = parse,
};
#ifndef RZ_PLUGIN_INCORE
RZ_API RzLibStruct rizin_plugin = {
.type = RZ_LIB_TYPE_PARSE,
.data = &rz_parse_plugin_tms320_pseudo,
.version = RZ_VERSION
};
#endif
rizin-0.7.4/librz/parse/p/parse_common.c 0000664 0001750 0001750 00000011205 14731035230 017535 0 ustar sophie sophie // SPDX-FileCopyrightText: 2018-2021 deroad
// SPDX-License-Identifier: LGPL-3.0-only
/** \file parse_common.c
* This file contains a common code that can be used to convert any asm code
* into a pseudo code, via a generic grammar.
*
* The grammar is quite simple; Let's take a simple example
*
* Let's take the following assembly
* ; intel x86 asm
* ; rax = rax + 10
* add rax, 10
*
* The associated grammar will be "1 += 2" the number 1 will be changed to "rax" and 2 with "10"
*
* another example:
*
* ; mips asm
* ; t0 = 4097 << 16
* lui t0, 4097
*
* The associated grammar will be "1 = 2 << #16" to notice the `#` symbol.
* The `#` symbol is used to ignore any set of chars after this till next whitespace/end of the line
*
* the developer has to provide a tokenize method to split the assembly in various token strings
* and
*/
typedef struct {
const char *mnemonic;
size_t mnemonic_length;
const char *grammar;
} RzPseudoGrammar;
typedef struct {
const char *expected;
const char *pseudo;
} RzPseudoDirect;
typedef struct {
const char *expected;
const char *replace;
int flag; // 0 for first match, 1 for all matches
} RzPseudoReplace;
typedef struct {
const RzPseudoDirect *direct;
size_t direct_length;
const RzPseudoReplace *replace;
size_t replace_length;
const RzPseudoGrammar *lexicon;
size_t lexicon_length;
int max_args;
RzList /**/ *(*tokenize)(const char *assembly, size_t length);
} RzPseudoConfig;
#define RZ_PSEUDO_DEFINE_GRAMMAR(x, y) \
{ .mnemonic = x, .mnemonic_length = sizeof(x) - 1, .grammar = y }
#define RZ_PSEUDO_DEFINE_DIRECT(x, y) \
{ .expected = x, .pseudo = y }
#define RZ_PSEUDO_DEFINE_REPLACE(x, y, f) \
{ .expected = x, .replace = y, .flag = f }
#define RZ_PSEUDO_DEFINE_CONFIG(d, l, r, m, t) \
{ \
.direct = d, \
.direct_length = RZ_ARRAY_SIZE(d), \
.replace = r, \
.replace_length = RZ_ARRAY_SIZE(r), \
.lexicon = l, \
.lexicon_length = RZ_ARRAY_SIZE(l), \
.max_args = m, \
.tokenize = t, \
}
#define RZ_PSEUDO_DEFINE_CONFIG_NO_DIRECT(l, r, m, t) \
{ \
.direct = NULL, \
.direct_length = 0, \
.replace = r, \
.replace_length = RZ_ARRAY_SIZE(r), \
.lexicon = l, \
.lexicon_length = RZ_ARRAY_SIZE(l), \
.max_args = m, \
.tokenize = t, \
}
#define RZ_PSEUDO_DEFINE_CONFIG_ONLY_LEXICON(l, m, t) \
{ \
.direct = NULL, \
.direct_length = 0, \
.replace = NULL, \
.replace_length = 0, \
.lexicon = l, \
.lexicon_length = RZ_ARRAY_SIZE(l), \
.max_args = m, \
.tokenize = t, \
}
static bool rz_pseudo_convert(const RzPseudoConfig *config, const char *assembly, RzStrBuf *sb) {
rz_return_val_if_fail(config && config->tokenize && config->lexicon, false);
size_t i, p;
const char *tmp = NULL;
const RzPseudoGrammar *gr = NULL;
const RzPseudoReplace *rp = NULL;
if (!strcmp(assembly, "invalid")) {
return true;
} else if (!strncmp(assembly, "trunc", 5)) {
return true;
} else if (!strcmp(assembly, "nop")) {
return true;
}
size_t length = strlen(assembly);
for (i = 0; i < config->direct_length; ++i) {
tmp = config->direct[i].expected;
if (!strcmp(assembly, tmp)) {
rz_strbuf_set(sb, config->direct[i].pseudo);
return true;
}
}
size_t mnemonic_length = length;
if ((tmp = strchr(assembly, ' '))) {
mnemonic_length = tmp - assembly;
}
for (i = 0; i < config->lexicon_length; ++i) {
gr = &config->lexicon[i];
if (gr->mnemonic_length == mnemonic_length && !strncmp(gr->mnemonic, assembly, mnemonic_length)) {
break;
}
gr = NULL;
}
if (!gr) {
rz_strbuf_setf(sb, "asm(\"%s\")", assembly);
return true;
}
RzList *tokens = config->tokenize(assembly, length);
if (!tokens) {
rz_strbuf_setf(sb, "asm(\"%s\")", assembly);
return true;
}
for (i = 0, p = 0; gr->grammar[p]; ++p) {
int index = gr->grammar[p] - '0';
if (index > 0 && index < config->max_args) {
tmp = (const char *)rz_list_get_n(tokens, index);
if (!tmp) {
tmp = "?";
}
rz_strbuf_append_n(sb, gr->grammar + i, p - i);
i = p + 1;
rz_strbuf_append(sb, tmp);
} else if (gr->grammar[p] == '#') {
rz_strbuf_append_n(sb, gr->grammar + i, p - i);
i = p + 1;
// Fast-forward so after the next p++ done by the for loop p points to the next
// whitespace (or the end of the string)
while (gr->grammar[p + 1] && !IS_WHITESPACE(gr->grammar[p + 1])) {
++p;
}
}
}
if (i < p) {
rz_strbuf_append_n(sb, gr->grammar + i, p - i);
}
char *result = rz_strbuf_drain_nofree(sb);
for (int i = 0; i < config->replace_length; ++i) {
rp = &config->replace[i];
result = rz_str_replace(result, rp->expected, rp->replace, rp->flag);
}
rz_strbuf_set(sb, result);
free(result);
rz_list_free(tokens);
return true;
}
rizin-0.7.4/librz/parse/p/parse_dalvik_pseudo.c 0000664 0001750 0001750 00000030157 14731035230 021105 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 deroad
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#include
#include
#include
#include
#include "parse_common.c"
static RzList /**/ *dalvik_tokenize(const char *assembly, size_t length);
static const RzPseudoGrammar dalvik_lexicon[] = {
RZ_PSEUDO_DEFINE_GRAMMAR("+iget-wide-volatile", "1 = (wide-volatile) 2 [3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("+invoke-interface/range", "call 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("+invoke-virtual-quick", "call 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("add-double", "1 = (double)(2 + 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("add-double", "1 = 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("add-double/2addr", "1 += (double)2"),
RZ_PSEUDO_DEFINE_GRAMMAR("add-int", "1 = (int)(2 + 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("add-int/2addr", "1 += 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("add-int/lit16", "1 = 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("add-int/lit8", "1 = 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("add-long", "1 = 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("aget", "1 = 2[3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("aget-boolean", "1 = (boolean) 2[3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("aget-byte", "1 = (byte) 2[3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("aget-char", "1 = (char) 2[3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("aget-object", "1 = (object) 2[3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("aget-short", "1 = (short) 2[3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("aget-wide", "1 = (wide) 2[3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("and-byte", "1 &= (byte) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("and-int", "1 &= (int) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("and-long/2addr", "1 &= (long) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("aput", "2[3] = 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("aput-boolean", "2[3] = (bool) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("aput-byte", "2[3] = (byte) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("aput-char", "2[3] = (char) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("aput-object", "2[3] = (object) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("aput-short", "2[3] = (short) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("aput-wide", "2[3] = (wide) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("array-length", "1 = Array.length (2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("check-cast", "if (1 instanceof 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmp-int", "1 = (2 == 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmp-long", "1 = (2 == 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmpg-double", "1 = (2 == 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmpg-float", "1 = (2 == 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmpl-double", "1 = (double)(2 == 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmpl-float", "1 = (float)(2 == 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmpl-int", "1 = (int)(2 == 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("const", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("const-class", "1 = (class) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("const-string", "1 = (string) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("const-string/jumbo", "1 = (jumbo-string) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("const-wide", "1 = (wide) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("const-wide/16", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("const-wide/32", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("const-wide/high16", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("const/16", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("const/4", "1 = (wide) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("const/high16", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("div-double", "1 = (double) 2 / 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("div-double/2addr", "1 /= (double) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("div-float", "1 = 2 / 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("div-float/2addr", "1 /= (float) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("div-int", "1 = (int)(2 / 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("div-int/2addr", "1 /= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("div-int/lit16", "1 = 2 / 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("div-int/lit8", "1 = 2 / 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("double-to-int", "1 = (int) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("double-to-long", "1 = (long) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("filled-new-array", "1 = new Array(2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("float-to-double", "1 = (double)(float) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("float-to-int", "1 = (int)(float) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("float-to-long", "1 = (long)(float) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("goto/16", "goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("goto/32", "goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("if-eq", "if (1 == 2) goto 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("if-eqz", "if (!1) goto 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("if-ge", "if (1 > zero) goto 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("if-gtz", "if (1 > 0) goto 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("if-le", "if (1 <= 2) goto 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("if-lt", "if (1 < 2) goto 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("if-ltz", "if (1 <=) goto 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("if-ne", "if (1 != 2) goto 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("if-nez", "if (1) goto 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("iget", "1 = 2[3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("iget-boolean", "1 = (bool) 2 [3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("iget-byte", "1 = (byte) 2 [3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("iget-char", "1 = (char) 2 [3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("iget-object", "1 = (2) 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("iget-short", "1 = (short) 2 [3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("iget-wide", "1 = (wide) 2 [3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("instance-of", "1 = insteanceof (2) == 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("int-to-byte", "1 = (byte) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("int-to-double", "1 = (double) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("int-to-long", "1 = (long) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("invoke-direct", "call 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("invoke-direct/range", "call 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("invoke-interface", "call 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("invoke-interface/range", "call 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("invoke-polymorphic", "call polymorphic 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("invoke-static", "call 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("invoke-super", "call super 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("invoke-super/range", "call super 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("invoke-virtual", "call 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("invoke-virtual/range", "call 2 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("iput", "2[3] = 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("iput-boolean", "2[3] = (bool) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("iput-byte", "2[3] = (byte) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("iput-char", "2[3] = (char) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("iput-int", "2[3] = (int) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("iput-object", "2[3] = (object) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("long-to-double", "1 = (double) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("long-to-float", "1 = (float)(long) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("long-to-int", "1 = (int)(long) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("move", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("move-exception", "1 = exception"),
RZ_PSEUDO_DEFINE_GRAMMAR("move-object", "1 = (object) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("move-object/16", "1 = (object) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("move-object/from16", "1 = (object) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("move-result", "1 = result"),
RZ_PSEUDO_DEFINE_GRAMMAR("move-result-object", "1 = (object) result"),
RZ_PSEUDO_DEFINE_GRAMMAR("move-result-wide", "1 = (wide) result"),
RZ_PSEUDO_DEFINE_GRAMMAR("move-wide", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("move-wide/16", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("move-wide/from16", "1 = (wide) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("move/16", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("move/from16", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mul-double", "1 = 2 * 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("mul-float", "1 = 2 * 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("mul-float/2addr", "1 *= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mul-int", "1 = (int)(2 * 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("mul-int/lit8", "1 = (2 * 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("mul-long", "1 = 2 * 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("neg-double", "1 = -2"),
RZ_PSEUDO_DEFINE_GRAMMAR("neg-float", "1 = -2"),
RZ_PSEUDO_DEFINE_GRAMMAR("neg-long", "1 = -2"),
RZ_PSEUDO_DEFINE_GRAMMAR("new-array", "1 = new array (2, 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("new-instance", "1 = 2.new"),
RZ_PSEUDO_DEFINE_GRAMMAR("nop", ""),
RZ_PSEUDO_DEFINE_GRAMMAR("not-int", "1 = !2"),
RZ_PSEUDO_DEFINE_GRAMMAR("or-int", "1 = (int)(2 | 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("or-int/2addr", "1 |= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("or-long", "1 |= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("packed-switch", "switch 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("rem-double", "1 = (double) 2 % 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("rem-double/2addr", "1 %= (double) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("rem-float", "1 = (float) 2 % 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("rem-float/2addr", "1 %= (float) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("rem-long", "1 = (long) 2 % 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("rem-long/2addr", "1 %= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("return-object", "return (object) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("return-void", "return"),
RZ_PSEUDO_DEFINE_GRAMMAR("return-wide", "return (wide) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("rsub-int", "1 = 2 - 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("sget", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sget-boolean", "1 = (bool) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sget-byte", "1 = (byte) 2 [3]"),
RZ_PSEUDO_DEFINE_GRAMMAR("sget-char", "1 = (char) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sget-object", "1 = (object) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sget-short", "1 = (short) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("shl-int", "1 = (int) 2 << 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("shl-int/2addr", "1 <<<= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("shl-long", "1 = (long) 2 << 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("shr-int", "1 = (int) 2 >> 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("shr-long", "1 = (long) 2 >> 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("shr-long/2addr", "1 >>= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sparse-switch", "switch 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sput", "1 = 2 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("sput-boolean", "2[3] = (bool) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sput-char", "2[3] = (char) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sput-object", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sput-wide", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub-float", "1 = 2 - 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub-float/2addr", "1 -= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub-int", "1 = (int) 2 - 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub-int", "1 = (int)(2 - 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub-int/2addr", "1 -= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub-long", "1 = (long) 2 - 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub-long/2addr", "1 -= (long) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("ushl-int/2addr", "1 <<<= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("ushr-int", "1 = (int) 2 >>> 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("ushr-int/2addr", "1 >>>= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("ushr-long", "1 = (long) 2 >>> 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("xor-byte", "1 = (byte)(2 ^ 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("xor-int", "1 = (int)(2 ^ 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("xor-int/2addr", "1 ^= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("xor-long", "1 = (long)(2 ^ 3)"),
RZ_PSEUDO_DEFINE_GRAMMAR("xor-short", "1 = (short)(2 ^ 3)"),
};
static const RzPseudoReplace dalvik_replace[] = {
RZ_PSEUDO_DEFINE_REPLACE("{", "(", 1),
RZ_PSEUDO_DEFINE_REPLACE("}", ")", 1),
RZ_PSEUDO_DEFINE_REPLACE(";", "", 1),
};
static const RzPseudoConfig dalvik_config = RZ_PSEUDO_DEFINE_CONFIG_NO_DIRECT(dalvik_lexicon, dalvik_replace, 4, dalvik_tokenize);
RzList /**/ *dalvik_tokenize(const char *assembly, size_t length) {
size_t i, p;
char *buf = NULL;
RzList *tokens = NULL;
const char *comma_replace = NULL;
bool keep = false;
buf = rz_str_ndup(assembly, length);
if (!buf) {
return NULL;
}
for (i = 0, p = 0; p < length; ++i, ++p) {
if (buf[p] == ',') {
if (!keep) {
p++;
} else if (buf[p + 1] == ' ') {
buf[i] = buf[p];
p++;
continue;
}
} else if (buf[p] == '{') {
keep = true;
comma_replace = ", ";
} else if (buf[p] == '}') {
keep = false;
}
if (p > i) {
buf[i] = buf[p];
}
}
buf[i] = 0;
tokens = rz_str_split_duplist(buf, " ", true);
free(buf);
if (!tokens) {
return NULL;
}
if (comma_replace) {
RzListIter *it;
rz_list_foreach (tokens, it, buf) {
char *repl = rz_str_replace(buf, ",", comma_replace, 1);
rz_list_iter_set_data(it, repl);
}
}
return tokens;
}
static bool parse(RzParse *parse, const char *assembly, RzStrBuf *sb) {
return rz_pseudo_convert(&dalvik_config, assembly, sb);
}
RzParsePlugin rz_parse_plugin_dalvik_pseudo = {
.name = "dalvik.pseudo",
.desc = "DALVIK pseudo syntax",
.init = NULL,
.fini = NULL,
.parse = parse,
};
#ifndef RZ_PLUGIN_INCORE
RZ_API RzLibStruct rizin_plugin = {
.type = RZ_LIB_TYPE_PARSE,
.data = &rz_parse_plugin_dalvik_pseudo,
.version = RZ_VERSION
};
#endif
rizin-0.7.4/librz/parse/p/parse_riscv_pseudo.c 0000664 0001750 0001750 00000012532 14731035230 020756 0 ustar sophie sophie // SPDX-FileCopyrightText: 2020 Aswin C (officialcjunior)
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
static int replace(int argc, const char *argv[], char *newstr) {
#define MAXPSEUDOOPS 10
int i, j, k, d;
char ch;
struct {
int narg;
char *op;
char *str;
int args[MAXPSEUDOOPS];
} ops[] = {
{ 0, "add", "# = # + #", { 1, 2, 3 } },
{ 0, "addi", "# = # + #", { 1, 2, 3 } },
{ 0, "and", "# = # & #", { 1, 2, 3 } },
{ 0, "andi", "# = # & #", { 1, 2, 3 } },
{ 0, "beq", "if (# == #) goto #", { 1, 2, 3 } },
{ 0, "bleu", "if (unsigned)# <= # goto #", { 1, 2, 3 } },
{ 0, "bltu", "if (unsigned)# < # goto #", { 1, 2, 3 } },
{ 0, "blt", "if (# < #) goto #", { 1, 2, 3 } },
{ 0, "beqz", "if (# == 0) goto #", { 1, 2 } },
{ 0, "bne", "if (# != #) goto #", { 1, 2, 3 } },
{ 0, "bnez", "if (# != 0) goto #", { 1, 2 } },
{ 0, "bgez", "if (# >= 0) goto #", { 1, 2 } },
{ 0, "bgtz", "if (# > 0) goto #", { 1, 2 } },
{ 0, "fld", "# = #", { 1, 2 } },
{ 0, "j", "jmp #", { 1 } },
{ 0, "jr", "jmp #", { 1 } },
{ 0, "jalr", "jmp #", { 1 } },
{ 0, "jal", "jmp #", { 1 } },
{ 0, "ld", "# = (double)[#]", { 1, 2 } },
{ 0, "li", "# = #", { 1, 2 } },
{ 0, "lh", "# = [#]", { 1, 2 } },
{ 0, "lui", "# = #", { 1, 2 } },
{ 0, "lbu", "# = (unsigned)[#]", { 1, 2 } },
{ 0, "lhu", "# = (unsigned)[#]", { 1, 2 } },
{ 0, "lw", "# = [#]", { 1, 2 } },
{ 0, "mv", "# = #", { 1, 2 } },
{ 0, "or", "# = # | #", { 1, 2, 3 } },
{ 0, "sd", "[#] = (double)#", { 2, 1 } },
{ 0, "sw", "[#] = #", { 2, 1 } },
{ 0, "sb", "[#] = #", { 2, 1 } },
{ 0, "sh", "[#] = #", { 2, 1 } },
{ 0, "sub", "# = # - #", { 1, 2, 3 } },
{ 0, NULL }
};
if (!newstr) {
return false;
}
for (i = 0; ops[i].op; i++) {
if (ops[i].narg) {
if (argc - 1 != ops[i].narg) {
continue;
}
}
if (!strcmp(ops[i].op, argv[0])) {
if (newstr) {
d = 0;
j = 0;
ch = ops[i].str[j];
for (j = 0, k = 0; ch != '\0'; j++, k++) {
ch = ops[i].str[j];
if (ch == '#') {
if (d >= MAXPSEUDOOPS) {
// XXX Shouldn't ever happen...
continue;
}
int idx = ops[i].args[d];
d++;
if (idx <= 0) {
// XXX Shouldn't ever happen...
continue;
}
const char *w = argv[idx];
if (w) {
strcpy(newstr + k, w);
k += strlen(w) - 1;
}
} else {
newstr[k] = ch;
}
}
newstr[k] = '\0';
}
rz_str_replace_char(newstr, '{', '(');
rz_str_replace_char(newstr, '}', ')');
return true;
}
}
/* TODO: this is slow */
newstr[0] = '\0';
for (i = 0; i < argc; i++) {
strcat(newstr, argv[i]);
strcat(newstr, (!i || i == argc - 1) ? " " : ",");
}
rz_str_replace_char(newstr, '{', '(');
rz_str_replace_char(newstr, '}', ')');
return false;
}
static bool parse(RzParse *p, const char *data, RzStrBuf *sb) {
char w0[256], w1[256], w2[256], w3[256];
char str[1024] = { 0 };
int i, len = strlen(data), n;
char *buf, *ptr, *optr, *num;
if (len >= sizeof(w0)) {
return false;
}
// malloc can be slow here :?
if (!(buf = malloc(len + 1))) {
return false;
}
memcpy(buf, data, len + 1);
if (*buf) {
*w0 = *w1 = *w2 = *w3 = '\0';
ptr = strchr(buf, ' ');
if (!ptr) {
ptr = strchr(buf, '\t');
}
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
;
}
strncpy(w0, buf, sizeof(w0) - 1);
strncpy(w1, ptr, sizeof(w1) - 1);
optr = ptr;
if (*ptr == '(') {
ptr = strchr(ptr + 1, ')');
}
if (ptr && *ptr == '[') {
ptr = strchr(ptr + 1, ']');
}
if (ptr && *ptr == '{') {
ptr = strchr(ptr + 1, '}');
}
if (!ptr) {
eprintf("Unbalanced bracket\n");
free(buf);
return false;
}
ptr = strchr(ptr, ',');
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
;
}
strncpy(w1, optr, sizeof(w1) - 1);
strncpy(w2, ptr, sizeof(w2) - 1);
optr = ptr;
ptr = strchr(ptr, ',');
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
;
}
strncpy(w2, optr, sizeof(w2) - 1);
strncpy(w3, ptr, sizeof(w3) - 1);
}
}
ptr = strchr(buf, '(');
if (ptr) {
*ptr = 0;
num = (char *)rz_str_lchr(buf, ' ');
if (!num) {
num = (char *)rz_str_lchr(buf, ',');
}
if (num) {
n = atoi(num + 1);
*ptr = '[';
rz_str_cpy(num + 1, ptr);
ptr = (char *)rz_str_lchr(buf, ']');
if (n && ptr) {
char *rest = strdup(ptr + 1);
size_t dist = len + 1 - (ptr - buf);
if (n > 0) {
snprintf(ptr, dist, "+%d]%s", n, rest);
} else {
snprintf(ptr, dist, "%d]%s", n, rest);
}
free(rest);
}
} else {
*ptr = '[';
}
}
}
{
const char *wa[] = { w0, w1, w2, w3 };
int nw = 0;
for (i = 0; i < 4; i++) {
if (wa[i][0]) {
nw++;
}
}
replace(nw, wa, str);
}
}
{
char *s = strdup(str);
s = rz_str_replace(s, "+ -", "- ", 1);
s = rz_str_replace(s, "- -", "+ ", 1);
rz_strf(str, "%s", s);
free(s);
}
free(buf);
rz_strbuf_set(sb, str);
return true;
}
RzParsePlugin rz_parse_plugin_riscv_pseudo = {
.name = "riscv.pseudo",
.desc = "riscv pseudo syntax",
.parse = parse,
};
#ifndef RZ_PLUGIN_INCORE
RZ_API RzLibStruct rizin_plugin = {
.type = RZ_LIB_TYPE_PARSE,
.data = &rz_parse_plugin_riscv_pseudo,
.version = RZ_VERSION
};
#endif
rizin-0.7.4/librz/parse/p/parse_arm_pseudo.c 0000664 0001750 0001750 00000031077 14731035230 020414 0 ustar sophie sophie // SPDX-FileCopyrightText: 2015-2018 pancake
// SPDX-FileCopyrightText: 2021 deroad
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "parse_common.c"
static RzList /**/ *arm_tokenize(const char *assembly, size_t length);
static const RzPseudoGrammar arm_lexicon[] = {
RZ_PSEUDO_DEFINE_GRAMMAR("abs", "1 = abs(1)"),
RZ_PSEUDO_DEFINE_GRAMMAR("adc", "1 = 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("add", "1 = 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("add.w", "1 = 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("adds", "1 = 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("addw", "1 = 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("adf", "1 = 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("adr", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("adrp", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("and", "1 = 2 & 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("ands", "1 &= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("asl", "1 = 2 << 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("asls", "1 = 2 << 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("asr", "1 = 2 >> 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("asrs", "1 = 2 >> 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("b", "goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("b.gt", "if (? > ?) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("b.le", "if (? < ?) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("b.w", "goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("beq", "if (? == ?) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("bge", "if (? >= ?) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("bkpt", "breakpoint 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("bl", "1 ()"),
RZ_PSEUDO_DEFINE_GRAMMAR("blx", "1 ()"),
RZ_PSEUDO_DEFINE_GRAMMAR("bxeq", "if (? == ?) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("call", "1 ()"),
RZ_PSEUDO_DEFINE_GRAMMAR("cbnz", "if (1) goto 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("cbz", "if (!1) goto 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmf", "if (1 == 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmn", "if (1 != 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmp", "if (1 == 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("div", "1 = 2 / 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("dvf", "1 = 2 / 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("eor", "1 = 2 ^ 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("fcmp", "if (1 == 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("fdiv", "1 = 2 / 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("fdv", "1 = 2 / 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("fml", "1 = 2 * 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("fmov", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("fmul", "1 = 2 * 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("fsub", "1 = 2 - 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldp", "(1, 2) = 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldr", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldr.w", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldrb", "1 = (byte) 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldrh", "1 = (word) 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldrsb", "1 = (byte) 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldrsw", "1 = 2 + 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldrsw", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("lsl", "1 = 2 << 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("lsls", "1 = 2 << 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("lsr", "1 = 2 >> 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("lsrs", "1 = 2 >> 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("mov", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("movk", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("movn", "1 = ~2"),
RZ_PSEUDO_DEFINE_GRAMMAR("movz", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("muf", "1 = 2 * 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("mul", "1 = 2 * 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("muls", "1 = 2 * 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("mvn", "1 = ~2"),
RZ_PSEUDO_DEFINE_GRAMMAR("neg", "1 = !2"),
RZ_PSEUDO_DEFINE_GRAMMAR("orr", "1 = 2 | 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("rmf", "1 = 2 % 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("sbc", "1 = 2 - 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("sqt", "1 = sqrt(2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("stp", "3 = (1, 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("str", "2 = 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("strb", "2 = (byte) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("strh", "2 = (half) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("strh.w", "2 = (half) 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("stur", "2 = 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub", "1 = 2 - 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("subs", "1 = 2 - 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("swp", "swap(1, 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("sxtb", "1 = (char) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sxth", "1 = (short) 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sxtw", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("tst", "if ((1 & 2) == 0)"),
RZ_PSEUDO_DEFINE_GRAMMAR("udf", "undefined 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("udiv", "1 = (unsigned) 2 / 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("vmov.i32", "1 = 2"),
/* arm thumb */
RZ_PSEUDO_DEFINE_GRAMMAR("lsl.w", "1 = 2 << 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("lsr.w", "1 = 2 >> 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("movs", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("movt", "1 |= 2 << #16"),
RZ_PSEUDO_DEFINE_GRAMMAR("movw", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("pop", "pop 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("pop.w", "pop 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("push", "push 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("push.w", "push 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub", "1 -= 2"), // THUMB
RZ_PSEUDO_DEFINE_GRAMMAR("sub.w", "1 = 2 - 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("subs", "1 -= 2"), // THUMB
RZ_PSEUDO_DEFINE_GRAMMAR("tst.w", "if ((1 & 2) == 0)"),
RZ_PSEUDO_DEFINE_GRAMMAR("vdiv.f64", "1 = (float) 2 / 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("vmov", "1 = (float) 2 . 3"),
RZ_PSEUDO_DEFINE_GRAMMAR("vpop", "pop(1)"),
RZ_PSEUDO_DEFINE_GRAMMAR("vpush", "push(1)"),
};
static const RzPseudoDirect arm_direct[] = {
RZ_PSEUDO_DEFINE_DIRECT("beq lr", "if (? == ?) return"),
RZ_PSEUDO_DEFINE_DIRECT("bx lr", "return"),
};
static const RzPseudoReplace arm_replace[] = {
RZ_PSEUDO_DEFINE_REPLACE(" + 0]", "]", 0),
RZ_PSEUDO_DEFINE_REPLACE("+ -", "- ", 1),
RZ_PSEUDO_DEFINE_REPLACE("0 << 16", "0", 1),
RZ_PSEUDO_DEFINE_REPLACE("{", "(", 1),
RZ_PSEUDO_DEFINE_REPLACE("}", ")", 1),
};
static const RzPseudoConfig arm_config = RZ_PSEUDO_DEFINE_CONFIG(arm_direct, arm_lexicon, arm_replace, 5, arm_tokenize);
RzList /**/ *arm_tokenize(const char *assembly, size_t length) {
size_t i, p;
char *buf = NULL;
const char *comma_replace = NULL;
bool keep = false;
RzList *tokens = NULL;
buf = rz_str_ndup(assembly, length);
if (!buf) {
return NULL;
}
for (i = 0, p = 0; p < length; ++i, ++p) {
if (buf[p] == ',') {
if (!keep) {
p++;
} else if (buf[p + 1] == ' ') {
buf[i] = buf[p];
p++;
continue;
}
} else if (buf[p] == '(') {
buf[p] = ' ';
} else if (buf[p] == ')') {
buf[p] = ' ';
} else if (buf[p] == '[') {
keep = true;
comma_replace = " + ";
} else if (buf[p] == ']') {
keep = false;
} else if (buf[p] == '{') {
if (strchr(buf + p + 1, ',') < strchr(buf + p + 1, '}')) {
keep = true;
comma_replace = ", ";
} else {
p++;
}
} else if (buf[p] == '}') {
if (!comma_replace) {
p++;
}
keep = false;
} else if ((buf[p] == 'w' || buf[p] == 'x') && buf[p + 1] == 'z' && buf[p + 2] == 'r') {
p += 2;
buf[p] = '0';
}
if (p > i) {
buf[i] = buf[p];
}
}
buf[i] = 0;
tokens = rz_str_split_duplist(buf, " ", true);
free(buf);
if (!tokens) {
return NULL;
}
if (comma_replace) {
RzListIter *it;
rz_list_foreach (tokens, it, buf) {
char *repl = rz_str_replace(buf, ",", comma_replace, 1);
rz_list_iter_set_data(it, repl);
}
}
return tokens;
}
static bool parse(RzParse *p, const char *assembly, RzStrBuf *sb) {
return rz_pseudo_convert(&arm_config, assembly, sb);
}
static bool op_is_stack_addr_addition(RzAnalysisOp *op) {
if (!op || (op->type != RZ_ANALYSIS_OP_TYPE_ADD && op->type != RZ_ANALYSIS_OP_TYPE_SUB)) {
return false;
} else if (op->dst && op->dst->reg &&
RZ_STR_ISNOTEMPTY(op->dst->reg->name) &&
(!rz_str_casecmp(op->dst->reg->name, "fp") ||
!rz_str_casecmp(op->dst->reg->name, "sp"))) {
// we do not want additions/subtractions which modifies the stack
return false;
}
for (size_t j = 0; j < 3; j++) {
if (!op->src[j] || !op->src[j]->reg ||
RZ_STR_ISEMPTY(op->src[j]->reg->name)) {
continue;
}
const char *reg_name = op->src[j]->reg->name;
if (!rz_str_casecmp(reg_name, "fp") || !rz_str_casecmp(reg_name, "sp")) {
return true;
}
}
return false;
}
static char *subvar_stack(RzParse *p, RzAnalysisOp *op, RZ_NULLABLE RzAnalysisFunction *f, char *tstr) {
const ut64 addr = op->addr;
if (!p->var_expr_for_reg_access || !f) {
return tstr;
}
const char *re_str;
int group_idx_sign = -1;
int group_idx_addend = 2;
bool brackets = true;
if (p->pseudo) {
// match e.g. "fp - 0x42"
// capturing "fp", "-", "0x42"
re_str = "\\[([a-z][0-9a-z][0-9]?)\\s*(\\+|-)\\s*(-?(0x)?[0-9a-f]+)\\]";
group_idx_sign = 2;
group_idx_addend = 3;
} else if (op_is_stack_addr_addition(op)) {
// only in add instructions like "add r7, sp, 0x42" we want to match
// without brackets around the "sp, 0x42". That is because we want to
// avoid matching cases like the following:
// * sub r7, sp, 0x42
// * sub sp, 0x42
// * add fp, sp, 4
// match e.g. "fp, -0x42"
// capturing "fp", "-0x42"
re_str = "([a-z][0-9a-z][0-9]?),\\s+(-?(0x)?[0-9a-f]+)";
brackets = false;
} else if (strchr(tstr, '[')) {
// match e.g. "[fp, -0x42]"
// capturing "fp", "-0x42"
re_str = "\\[([a-z][0-9a-z][0-9]?),\\s+(-?(0x)?[0-9a-f]+)\\]";
} else {
return tstr;
}
RzRegex *var_re = rz_regex_new(re_str, RZ_REGEX_EXTENDED | RZ_REGEX_CASELESS, 0);
if (!var_re) {
return tstr;
}
RzPVector *matches = rz_regex_match_first(var_re, tstr, RZ_REGEX_ZERO_TERMINATED, 0, RZ_REGEX_DEFAULT);
if (!matches || rz_pvector_empty(matches)) {
rz_regex_free(var_re);
rz_pvector_free(matches);
return tstr;
}
rz_regex_free(var_re);
RzRegexMatch *match = rz_pvector_at(matches, 1);
char *reg_str = rz_str_ndup(tstr + match->start, match->len);
if (!reg_str) {
rz_pvector_free(matches);
return tstr;
}
rz_return_val_if_fail(rz_pvector_len(matches) >= group_idx_addend, tstr);
match = rz_pvector_at(matches, group_idx_addend);
const char *addend_str = tstr + match->start;
st64 reg_addend = strtoll(addend_str, NULL, 0);
if (group_idx_sign >= 0) {
rz_return_val_if_fail(rz_pvector_len(matches) >= group_idx_sign, tstr);
match = rz_pvector_at(matches, group_idx_sign);
char sign = tstr[match->start];
if (sign == '-') {
reg_addend = -reg_addend;
}
}
char *varstr = p->var_expr_for_reg_access(f, addr, reg_str, reg_addend);
if (!varstr) {
free(reg_str);
rz_pvector_free(matches);
return tstr;
}
// replace!
RzRegexMatch *match_full = rz_pvector_at(matches, 0);
size_t tail_len = strlen(tstr) - (match_full->start + match_full->len);
RzStrBuf sb;
rz_strbuf_init(&sb);
// reserve with a bit of padding for brackets, reg, whitespace, ...
rz_strbuf_reserve(&sb, match_full->start + strlen(varstr) + tail_len + 32);
rz_strbuf_append_n(&sb, tstr, match_full->start);
if (brackets) {
rz_strbuf_append(&sb, "[");
}
if (!p->localvar_only) {
rz_strbuf_appendf(&sb, "%s %c ", reg_str, reg_addend < 0 ? '-' : '+');
}
rz_strbuf_append(&sb, varstr);
if (brackets) {
rz_strbuf_append(&sb, "]");
}
rz_strbuf_append_n(&sb, tstr + match_full->start + match_full->len, tail_len);
free(reg_str);
free(varstr);
free(tstr);
rz_pvector_free(matches);
return rz_strbuf_drain_nofree(&sb);
}
static bool subvar(RzParse *p, RzAnalysisFunction *f, RzAnalysisOp *op, char *data, char *str, int len) {
const ut64 addr = op->addr;
const int oplen = op->size;
char *tstr = strdup(data);
if (!tstr) {
return false;
}
if (p->subrel) {
char *rip;
if (p->pseudo) {
rip = (char *)rz_str_casestr(tstr, "[pc +");
if (!rip) {
rip = (char *)rz_str_casestr(tstr, "[pc -");
}
} else {
rip = (char *)rz_str_casestr(tstr, "[pc, ");
}
if (rip) {
rip += 4;
char *tstr_new, *ripend = strchr(rip, ']');
const char *neg = strchr(rip, '-');
ut64 off = (oplen == 2 || strstr(tstr, ".w") || strstr(tstr, ".W")) ? 4 : 8;
ut64 repl_num = (addr + off) & ~3;
if (!ripend) {
ripend = "]";
}
const char *maybe_num = neg ? neg + 1 : rip;
maybe_num = rz_str_trim_head_ro(maybe_num);
if (rz_is_valid_input_num_value(NULL, maybe_num)) {
if (neg) {
repl_num -= rz_num_get(NULL, maybe_num);
} else {
repl_num += rz_num_get(NULL, maybe_num);
}
rip -= 3;
*rip = 0;
tstr_new = rz_str_newf("%s0x%08" PFMT64x "%s", tstr, repl_num, ripend);
free(tstr);
tstr = tstr_new;
}
}
}
tstr = subvar_stack(p, op, f, tstr);
if (len > strlen(tstr)) {
strcpy(str, tstr);
} else {
// TOO BIG STRING CANNOT REPLACE HERE
free(tstr);
return false;
}
free(tstr);
return true;
}
RzParsePlugin rz_parse_plugin_arm_pseudo = {
.name = "arm.pseudo",
.desc = "ARM/ARM64 pseudo syntax",
.parse = parse,
.subvar = &subvar,
};
#ifndef RZ_PLUGIN_INCORE
RZ_API RzLibStruct rizin_plugin = {
.type = RZ_LIB_TYPE_PARSE,
.data = &rz_parse_plugin_arm_pseudo,
.version = RZ_VERSION
};
#endif
rizin-0.7.4/librz/parse/p/parse_att2intel.c 0000664 0001750 0001750 00000007362 14731035230 020164 0 ustar sophie sophie // SPDX-FileCopyrightText: 2011 pancake
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#include
#include
#include
#include
static int replace(int argc, const char *argv[], char *newstr) {
int i, j, k;
struct {
char *op;
char *str;
} ops[] = {
{ "cmpl", "cmp 2, 1" },
{ "testl", "test 2, 1" },
{ "leal", "lea 2, 1" },
{ "movl", "mov 2, 1" },
{ "xorl", "xor 2, 1" },
{ "andl", "and 2, 1" },
{ "orl", "or 2, 1" },
{ "addl", "add 2, 1" },
{ "incl", "inc 1" },
{ "decl", "dec 1" },
{ "subl", "sub 2, 1" },
{ "mull", "mul 2, 1" },
{ "divl", "div 2, 1" },
{ "pushl", "push 1" },
{ "popl", "pop 1" },
{ "ret", "ret" },
{ NULL }
};
for (i = 0; ops[i].op != NULL; i++) {
if (!strcmp(ops[i].op, argv[0])) {
if (newstr != NULL) {
for (j = k = 0; ops[i].str[j] != '\0'; j++, k++) {
if (ops[i].str[j] >= '0' && ops[i].str[j] <= '9') {
const char *w = argv[ops[i].str[j] - '0'];
if (w != NULL) {
strcpy(newstr + k, w);
k += strlen(w) - 1;
}
} else {
newstr[k] = ops[i].str[j];
}
}
newstr[k] = '\0';
}
return true;
}
}
/* TODO: this is slow */
if (newstr != NULL) {
newstr[0] = '\0';
for (i = 0; i < argc; i++) {
strcat(newstr, argv[i]);
strcat(newstr, (i == 0 || i == argc - 1) ? " " : ",");
}
}
return false;
}
static bool parse(RzParse *p, const char *data, RzStrBuf *sb) {
int i, n;
char w0[32];
char w1[32];
char w2[32];
char w3[32];
char str[1024] = { 0 };
char *buf, *ptr, *optr, *num;
// malloc can be slow here :?
buf = strdup(data);
if (!buf) {
return false;
}
rz_str_trim_head(buf);
ptr = strchr(buf, '#');
if (ptr) {
*ptr = 0;
rz_str_trim(buf);
}
if (*buf == '.' || buf[strlen(buf) - 1] == ':') {
free(buf);
strcpy(str, data);
return true;
}
rz_str_replace_char(buf, '$', 0);
rz_str_replace_char(buf, '%', 0);
rz_str_replace_char(buf, '\t', ' ');
rz_str_replace_char(buf, '(', '[');
rz_str_replace_char(buf, ')', ']');
ptr = strchr(buf, '[');
if (ptr) {
*ptr = 0;
num = (char *)rz_str_lchr(buf, ' ');
if (!num) {
num = (char *)rz_str_lchr(buf, ',');
}
if (num) {
n = atoi(num + 1);
*ptr = '[';
rz_str_cpy(num + 1, ptr);
ptr = (char *)rz_str_lchr(buf, ']');
if (n && ptr) {
char *rest = strdup(ptr + 1);
size_t dist = strlen(data) + 1 - (ptr - buf);
snprintf(ptr, dist, "%+d]%s", n, rest);
free(rest);
}
} else {
*ptr = '[';
}
}
if (*buf) {
*w0 = *w1 = *w2 = *w3 = 0;
ptr = strchr(buf, ' ');
if (!ptr) {
ptr = strchr(buf, '\t');
}
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
;
}
strncpy(w0, buf, sizeof(w0) - 1);
strncpy(w1, ptr, sizeof(w1) - 1);
optr = ptr;
ptr = strchr(ptr, ',');
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
;
}
strncpy(w1, optr, sizeof(w1) - 1);
strncpy(w2, ptr, sizeof(w2) - 1);
ptr = strchr(ptr, ',');
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
;
}
strncpy(w2, optr, sizeof(w2) - 1);
strncpy(w3, ptr, sizeof(w3) - 1);
}
}
}
{
const char *wa[] = { w0, w1, w2, w3 };
int nw = 0;
for (i = 0; i < 4; i++) {
if (wa[i][0] != '\0') {
nw++;
}
}
replace(nw, wa, str);
}
}
free(buf);
rz_strbuf_set(sb, str);
return true;
}
RzParsePlugin rz_parse_plugin_att2intel = {
.name = "att2intel",
.desc = "X86 att 2 intel plugin",
.init = NULL,
.fini = NULL,
.parse = &parse,
};
#ifndef RZ_PLUGIN_INCORE
RZ_API RzLibStruct rizin_plugin = {
.type = RZ_LIB_TYPE_PARSE,
.data = &rz_parse_plugin_att2intel,
.version = RZ_VERSION
};
#endif
rizin-0.7.4/librz/parse/p/parse_6502_pseudo.c 0000664 0001750 0001750 00000007776 14731035230 020242 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 deroad
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#include
#include
#include
#include
#include "parse_common.c"
static RzList /**/ *_6502_tokenize(const char *assembly, size_t length);
static const RzPseudoGrammar _6502_lexicon[] = {
RZ_PSEUDO_DEFINE_GRAMMAR("adc", "a += (1 + 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("and", "a &= (1 + 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("asl", "a = 1 << #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("bcc", "if (carry == 0) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("bcs", "if (carry != 0) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("beq", "if (eq) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("bmi", "if (lt) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("bne", "if (ne) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("bpl", "if (gt) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("brk", "break"),
RZ_PSEUDO_DEFINE_GRAMMAR("clc", "carry = 0"),
RZ_PSEUDO_DEFINE_GRAMMAR("cld", "decimal = 0"),
RZ_PSEUDO_DEFINE_GRAMMAR("cli", "interrupt = 0"),
RZ_PSEUDO_DEFINE_GRAMMAR("clv", "overflow = 0"),
RZ_PSEUDO_DEFINE_GRAMMAR("cmp", "cmp (1, 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("cpx", "cmp (x, 1)"),
RZ_PSEUDO_DEFINE_GRAMMAR("cpy", "cmp (y, 1)"),
RZ_PSEUDO_DEFINE_GRAMMAR("dcx", "x--"),
RZ_PSEUDO_DEFINE_GRAMMAR("dcy", "y--"),
RZ_PSEUDO_DEFINE_GRAMMAR("dec", "(1 + 2)--"),
RZ_PSEUDO_DEFINE_GRAMMAR("dex", "x--"),
RZ_PSEUDO_DEFINE_GRAMMAR("dey", "y--"),
RZ_PSEUDO_DEFINE_GRAMMAR("eor", "a ^= (1 + 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("inc", "(1 + 2)++"),
RZ_PSEUDO_DEFINE_GRAMMAR("inc", "1++"),
RZ_PSEUDO_DEFINE_GRAMMAR("inx", "x++"),
RZ_PSEUDO_DEFINE_GRAMMAR("iny", "y++"),
RZ_PSEUDO_DEFINE_GRAMMAR("jmp", "goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("jsr", "1 ()"),
RZ_PSEUDO_DEFINE_GRAMMAR("lda", "a = (1 + 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldx", "x = (1 + 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldy", "y = (1 + 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("nop", ""),
RZ_PSEUDO_DEFINE_GRAMMAR("ora", "a |= (1 + 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("pha", "push a"),
RZ_PSEUDO_DEFINE_GRAMMAR("rti", "return"),
RZ_PSEUDO_DEFINE_GRAMMAR("rts", "return"),
RZ_PSEUDO_DEFINE_GRAMMAR("sbc", "a -= (1 + 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("sec", "carry = #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sed", "decimal = #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sei", "interrupt = #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sta", "[1 + 2] = a"),
RZ_PSEUDO_DEFINE_GRAMMAR("stx", "[1 + 2] = x"),
RZ_PSEUDO_DEFINE_GRAMMAR("sty", "[1 + 2] = y"),
RZ_PSEUDO_DEFINE_GRAMMAR("tax", "x = a"),
RZ_PSEUDO_DEFINE_GRAMMAR("tay", "y = a"),
RZ_PSEUDO_DEFINE_GRAMMAR("tsx", "x = s"),
RZ_PSEUDO_DEFINE_GRAMMAR("txa", "a = x"),
RZ_PSEUDO_DEFINE_GRAMMAR("txs", "s = x"),
RZ_PSEUDO_DEFINE_GRAMMAR("tya", "a = y"),
};
static const RzPseudoConfig _6502_config = RZ_PSEUDO_DEFINE_CONFIG_ONLY_LEXICON(_6502_lexicon, 3, _6502_tokenize);
RzList /**/ *_6502_tokenize(const char *assembly, size_t length) {
size_t i, p;
char *buf = NULL;
bool insert_zero = false;
RzList *tokens = NULL;
buf = rz_str_ndup(assembly, length);
if (!buf) {
return NULL;
}
for (i = 0, p = 0; p < length; ++i, ++p) {
if (buf[p] == ',') {
buf[p] = ' ';
} else if (buf[p] == '#') {
p++;
} else if (buf[p] == '(') {
buf[p] = ' ';
if (!IS_HEXCHAR(buf[p - 1])) {
p++;
insert_zero = true;
}
} else if (buf[p] == ')') {
buf[p] = 0;
}
if (p > i) {
buf[i] = buf[p];
}
}
buf[i] = 0;
tokens = rz_str_split_duplist(buf, " ", true);
free(buf);
if (!tokens) {
return NULL;
}
if (insert_zero) {
rz_list_insert(tokens, rz_list_length(tokens) - 1, strdup("0"));
}
return tokens;
}
static bool parse(RzParse *parse, const char *assembly, RzStrBuf *sb) {
return rz_pseudo_convert(&_6502_config, assembly, sb);
}
RzParsePlugin rz_parse_plugin_6502_pseudo = {
.name = "6502.pseudo",
.desc = "6502 pseudo syntax",
.parse = parse,
};
#ifndef RZ_PLUGIN_INCORE
RZ_API RzLibStruct rizin_plugin = {
.type = RZ_LIB_TYPE_PARSE,
.data = &rz_parse_plugin_6502_pseudo,
.version = RZ_VERSION
};
#endif
rizin-0.7.4/librz/parse/p/parse_avr_pseudo.c 0000664 0001750 0001750 00000013146 14731035230 020422 0 ustar sophie sophie // SPDX-FileCopyrightText: 2021 deroad
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include
#include
#include
#include
#include
#include
#include "parse_common.c"
static RzList /**/ *avr_tokenize(const char *assembly, size_t length);
static const RzPseudoGrammar avr_lexicon[] = {
RZ_PSEUDO_DEFINE_GRAMMAR("adc", "1 += 2 + carry"),
RZ_PSEUDO_DEFINE_GRAMMAR("add", "1 += 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("adiw", "1+#1:1 += 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("and", "1 &= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("andi", "1 &= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("asr", "1 >>= 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("breq", "if(!var) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("brge", "if(var >= 0) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("brlo", "if(var < 0) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("brlt", "if(var < 0) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("brmi", "if(var < 0) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("brne", "if(var) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("brpl", "if(var > 0) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("brsh", "if(var >= 0) goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("call", "goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("cbr", "1 &= (#0xff - 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("clc", "c = #0"),
RZ_PSEUDO_DEFINE_GRAMMAR("clh", "h = #0"),
RZ_PSEUDO_DEFINE_GRAMMAR("cli", "i = #0"),
RZ_PSEUDO_DEFINE_GRAMMAR("cln", "n = #0"),
RZ_PSEUDO_DEFINE_GRAMMAR("clr", "1 ^= 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("cls", "s = #0"),
RZ_PSEUDO_DEFINE_GRAMMAR("clt", "t = #0"),
RZ_PSEUDO_DEFINE_GRAMMAR("clv", "v = #0"),
RZ_PSEUDO_DEFINE_GRAMMAR("clz", "z = #0"),
RZ_PSEUDO_DEFINE_GRAMMAR("com", "1 = #0xff - 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("cp", "var = 1 - 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("cpc", "var = 1 - 2 - carry"),
RZ_PSEUDO_DEFINE_GRAMMAR("cpi", "var = 1 - 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("cpse", "if(1 == 2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("dec", "1--"),
RZ_PSEUDO_DEFINE_GRAMMAR("eor", "1 ^= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("halt", "_halt()"),
RZ_PSEUDO_DEFINE_GRAMMAR("icall", "goto z"),
RZ_PSEUDO_DEFINE_GRAMMAR("ijmp", "goto z"),
RZ_PSEUDO_DEFINE_GRAMMAR("in", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("inc", "1++"),
RZ_PSEUDO_DEFINE_GRAMMAR("iret", "return_interrupt()"),
RZ_PSEUDO_DEFINE_GRAMMAR("jmp", "goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("ld", "1 = *(2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldd", "1 = *(2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("ldi", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("lds", "1 = *(2)"),
RZ_PSEUDO_DEFINE_GRAMMAR("lpm", "r0 = z"),
RZ_PSEUDO_DEFINE_GRAMMAR("lsl", "1 <<= #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("lsr", "1 >>= #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("mov", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("movw", "1+#1:1 = 2+#1:2"),
RZ_PSEUDO_DEFINE_GRAMMAR("mul", "#r1:r0 = 1 * 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("neg", "1 = -1"),
RZ_PSEUDO_DEFINE_GRAMMAR("nop", ""),
RZ_PSEUDO_DEFINE_GRAMMAR("or", "1 |= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("ori", "1 |= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("out", "1 = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("pop", "1 = pop()"),
RZ_PSEUDO_DEFINE_GRAMMAR("push", "push(1)"),
RZ_PSEUDO_DEFINE_GRAMMAR("rcall", "goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("ret", "return"),
RZ_PSEUDO_DEFINE_GRAMMAR("rjmp", "goto 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("rol", "1 = (1 << #1) | (1 >> #7)"),
RZ_PSEUDO_DEFINE_GRAMMAR("ror", "1 = (1 << #7) | (1 >> #1)"),
RZ_PSEUDO_DEFINE_GRAMMAR("sbc", "1 -= (2 + carry)"),
RZ_PSEUDO_DEFINE_GRAMMAR("sbci", "1 -= (2 + carry)"),
RZ_PSEUDO_DEFINE_GRAMMAR("sbiw", "1+#1:1 -= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sbrc", "if((1 & (#1 << 2)) != #0)"),
RZ_PSEUDO_DEFINE_GRAMMAR("sbrs", "if((1 & (#1 << 2)) != #1)"),
RZ_PSEUDO_DEFINE_GRAMMAR("sbr", "1 |= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sec", "c = #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("seh", "h = #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sei", "i = #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sen", "n = #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("ser", "1 = #0xff"),
RZ_PSEUDO_DEFINE_GRAMMAR("ses", "s = #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("set", "t = #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sev", "v = #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("sez", "z = #1"),
RZ_PSEUDO_DEFINE_GRAMMAR("st", "*(1) = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("std", "*(1) = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sts", "*(1) = 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("sub", "1 -= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("subi", "1 -= 2"),
RZ_PSEUDO_DEFINE_GRAMMAR("swap", "1 = ((1 & #0xf0) >> #4) | ((1 & #0x0f) << #4)"),
RZ_PSEUDO_DEFINE_GRAMMAR("tst", "1 &= 1"),
RZ_PSEUDO_DEFINE_GRAMMAR("wdr", "_watchdog_reset()"),
};
static const RzPseudoConfig avr_config = RZ_PSEUDO_DEFINE_CONFIG_ONLY_LEXICON(avr_lexicon, 3, avr_tokenize);
RzList /**/ *avr_tokenize(const char *assembly, size_t length) {
size_t i, p;
char *buf = NULL;
bool insert_zero = false;
RzList *tokens = NULL;
buf = rz_str_ndup(assembly, length);
if (!buf) {
return NULL;
}
for (i = 0, p = 0; p < length; ++i, ++p) {
if (buf[p] == ',') {
p++;
} else if (buf[p] == '(') {
buf[p] = ' ';
if (!IS_HEXCHAR(buf[p - 1])) {
p++;
insert_zero = true;
}
} else if (buf[p] == ')') {
buf[p] = 0;
}
if (p > i) {
buf[i] = buf[p];
}
}
buf[i] = 0;
tokens = rz_str_split_duplist(buf, " ", true);
free(buf);
if (!tokens) {
return NULL;
}
if (insert_zero) {
rz_list_insert(tokens, rz_list_length(tokens) - 1, strdup("0"));
}
return tokens;
}
static bool parse(RzParse *parse, const char *assembly, RzStrBuf *sb) {
return rz_pseudo_convert(&avr_config, assembly, sb);
}
RzParsePlugin rz_parse_plugin_avr_pseudo = {
.name = "avr.pseudo",
.desc = "AVR pseudo syntax",
.parse = parse
};
#ifndef RZ_PLUGIN_INCORE
RZ_API RzLibStruct rizin_plugin = {
.type = RZ_LIB_TYPE_PARSE,
.data = &rz_parse_plugin_avr_pseudo,
.version = RZ_VERSION
};
#endif
rizin-0.7.4/librz/parse/p/parse_wasm_pseudo.c 0000664 0001750 0001750 00000002313 14731035230 020573 0 ustar sophie sophie // SPDX-FileCopyrightText: 2019 deroad
// SPDX-License-Identifier: LGPL-3.0-only
#include
#include
#include