├── .idea ├── .name ├── vcs.xml ├── compiler.xml ├── kotlinc.xml ├── migrations.xml ├── deploymentTargetSelector.xml ├── misc.xml ├── gradle.xml └── runConfigurations.xml ├── app ├── .gitignore ├── src │ ├── main │ │ ├── res │ │ │ ├── values │ │ │ │ ├── strings.xml │ │ │ │ ├── ic_launcher_background.xml │ │ │ │ ├── colors.xml │ │ │ │ └── themes.xml │ │ │ ├── res │ │ │ │ ├── values │ │ │ │ │ ├── strings.xml │ │ │ │ │ ├── ic_launcher_background.xml │ │ │ │ │ ├── colors.xml │ │ │ │ │ └── themes.xml │ │ │ │ ├── mipmap-hdpi │ │ │ │ │ ├── ic_launcher.webp │ │ │ │ │ ├── ic_launcher_round.webp │ │ │ │ │ └── ic_launcher_foreground.webp │ │ │ │ ├── mipmap-mdpi │ │ │ │ │ ├── ic_launcher.webp │ │ │ │ │ ├── ic_launcher_round.webp │ │ │ │ │ └── ic_launcher_foreground.webp │ │ │ │ ├── mipmap-xhdpi │ │ │ │ │ ├── ic_launcher.webp │ │ │ │ │ ├── ic_launcher_round.webp │ │ │ │ │ └── ic_launcher_foreground.webp │ │ │ │ ├── mipmap-xxhdpi │ │ │ │ │ ├── ic_launcher.webp │ │ │ │ │ ├── ic_launcher_round.webp │ │ │ │ │ └── ic_launcher_foreground.webp │ │ │ │ ├── mipmap-xxxhdpi │ │ │ │ │ ├── ic_launcher.webp │ │ │ │ │ ├── ic_launcher_round.webp │ │ │ │ │ └── ic_launcher_foreground.webp │ │ │ │ ├── mipmap-anydpi-v26 │ │ │ │ │ ├── ic_launcher.xml │ │ │ │ │ └── ic_launcher_round.xml │ │ │ │ ├── xml │ │ │ │ │ ├── backup_rules.xml │ │ │ │ │ └── data_extraction_rules.xml │ │ │ │ ├── values-night │ │ │ │ │ └── themes.xml │ │ │ │ ├── layout │ │ │ │ │ └── activity_main.xml │ │ │ │ └── drawable │ │ │ │ │ ├── ic_launcher_foreground.xml │ │ │ │ │ └── ic_launcher_background.xml │ │ │ ├── mipmap-hdpi │ │ │ │ ├── ic_launcher.webp │ │ │ │ ├── ic_launcher_round.webp │ │ │ │ └── ic_launcher_foreground.webp │ │ │ ├── mipmap-mdpi │ │ │ │ ├── ic_launcher.webp │ │ │ │ ├── ic_launcher_round.webp │ │ │ │ └── ic_launcher_foreground.webp │ │ │ ├── mipmap-xhdpi │ │ │ │ ├── ic_launcher.webp │ │ │ │ ├── ic_launcher_round.webp │ │ │ │ └── ic_launcher_foreground.webp │ │ │ ├── mipmap-xxhdpi │ │ │ │ ├── ic_launcher.webp │ │ │ │ ├── ic_launcher_round.webp │ │ │ │ └── ic_launcher_foreground.webp │ │ │ ├── mipmap-xxxhdpi │ │ │ │ ├── ic_launcher.webp │ │ │ │ ├── ic_launcher_round.webp │ │ │ │ └── ic_launcher_foreground.webp │ │ │ ├── mipmap-anydpi-v26 │ │ │ │ ├── ic_launcher.xml │ │ │ │ └── ic_launcher_round.xml │ │ │ ├── xml │ │ │ │ ├── backup_rules.xml │ │ │ │ └── data_extraction_rules.xml │ │ │ ├── values-night │ │ │ │ └── themes.xml │ │ │ ├── layout │ │ │ │ └── activity_main.xml │ │ │ └── drawable │ │ │ │ ├── ic_launcher_foreground.xml │ │ │ │ └── ic_launcher_background.xml │ │ ├── ic_launcher-playstore.png │ │ ├── cpp │ │ │ ├── native-lib.cpp │ │ │ └── CMakeLists.txt │ │ ├── AndroidManifest.xml │ │ └── java │ │ │ └── com │ │ │ └── linux │ │ │ └── skroot │ │ │ └── next │ │ │ └── MainActivity.kt │ ├── test │ │ └── java │ │ │ └── com │ │ │ └── linux │ │ │ └── skroot │ │ │ └── next │ │ │ └── ExampleUnitTest.kt │ └── androidTest │ │ └── java │ │ └── com │ │ └── linux │ │ └── skroot │ │ └── next │ │ └── ExampleInstrumentedTest.kt ├── proguard-rules.pro └── build.gradle.kts ├── docr ├── ipc_home │ └── icr_skroot.png └── business_card │ └── skroot-Next名片.zip ├── gradle ├── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties └── libs.versions.toml ├── patch_kernel_root ├── 3rdparty │ ├── capstone-4.0.2-win64 │ │ ├── capstone.dll │ │ ├── capstone.lib │ │ ├── cstool.exe │ │ ├── capstone_dll.lib │ │ ├── RELEASE_NOTES │ │ ├── include │ │ │ ├── windowsce │ │ │ │ ├── intrin.h │ │ │ │ └── stdint.h │ │ │ ├── platform.h │ │ │ └── capstone │ │ │ │ ├── platform.h │ │ │ │ ├── evm.h │ │ │ │ ├── xcore.h │ │ │ │ ├── tms320c64x.h │ │ │ │ ├── sparc.h │ │ │ │ ├── m680x.h │ │ │ │ └── m68k.h │ │ ├── SPONSORS.TXT │ │ ├── LICENSE.TXT │ │ ├── README.md │ │ ├── CREDITS.TXT │ │ └── LICENSE_LLVM.TXT │ └── find_mrs_register.h ├── kernel_version_parser.h ├── kernel_symbol_parser.h ├── analyze_kernel.h ├── base_func.h ├── kernel_version_parser.cpp ├── kernel_symbol_parser.cpp ├── kallsyms_lookup_name_4_6_0.h ├── kallsyms_lookup_name.h ├── ARM_asm.h ├── kallsyms_lookup_name_6_1_42.h ├── analyze_kernel.cpp ├── kallsyms_lookup_name.cpp └── kallsyms_lookup_name_4_6_0.cpp ├── .github └── ISSUE_TEMPLATE │ ├── custom.md │ ├── feature_request.md │ └── bug_report.md ├── .gitignore ├── settings.gradle.kts ├── gradle.properties ├── README.md ├── gradlew.bat └── gradlew /.idea/.name: -------------------------------------------------------------------------------- 1 | Skroot Next -------------------------------------------------------------------------------- /app/.gitignore: -------------------------------------------------------------------------------- 1 | /build -------------------------------------------------------------------------------- /docr/ipc_home/icr_skroot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/docr/ipc_home/icr_skroot.png -------------------------------------------------------------------------------- /app/src/main/res/values/strings.xml: -------------------------------------------------------------------------------- 1 | 2 | Skroot Next 3 | -------------------------------------------------------------------------------- /app/src/main/res/res/values/strings.xml: -------------------------------------------------------------------------------- 1 | 2 | Skroot Next 3 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /docr/business_card/skroot-Next名片.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/docr/business_card/skroot-Next名片.zip -------------------------------------------------------------------------------- /app/src/main/ic_launcher-playstore.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/ic_launcher-playstore.png -------------------------------------------------------------------------------- /app/src/main/res/mipmap-hdpi/ic_launcher.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-mdpi/ic_launcher.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-xhdpi/ic_launcher.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-xxhdpi/ic_launcher.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-hdpi/ic_launcher.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-hdpi/ic_launcher.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-mdpi/ic_launcher.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-mdpi/ic_launcher.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-xhdpi/ic_launcher.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-xhdpi/ic_launcher.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-hdpi/ic_launcher_round.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher_round.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-mdpi/ic_launcher_round.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher_round.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-xxhdpi/ic_launcher.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-xxhdpi/ic_launcher.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-xxxhdpi/ic_launcher.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-xxxhdpi/ic_launcher.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-hdpi/ic_launcher_round.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-hdpi/ic_launcher_round.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-mdpi/ic_launcher_round.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-mdpi/ic_launcher_round.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-hdpi/ic_launcher_foreground.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher_foreground.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-mdpi/ic_launcher_foreground.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher_foreground.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-xhdpi/ic_launcher_foreground.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher_foreground.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-xhdpi/ic_launcher_round.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-xhdpi/ic_launcher_round.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-xxhdpi/ic_launcher_round.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-xxhdpi/ic_launcher_round.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.webp -------------------------------------------------------------------------------- /app/src/main/res/mipmap-xxxhdpi/ic_launcher_foreground.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/mipmap-xxxhdpi/ic_launcher_foreground.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-hdpi/ic_launcher_foreground.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-hdpi/ic_launcher_foreground.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-mdpi/ic_launcher_foreground.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-mdpi/ic_launcher_foreground.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-xxxhdpi/ic_launcher_round.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-xxxhdpi/ic_launcher_round.webp -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/capstone.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/patch_kernel_root/3rdparty/capstone-4.0.2-win64/capstone.dll -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/capstone.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/patch_kernel_root/3rdparty/capstone-4.0.2-win64/capstone.lib -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/cstool.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/patch_kernel_root/3rdparty/capstone-4.0.2-win64/cstool.exe -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-xhdpi/ic_launcher_foreground.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-xhdpi/ic_launcher_foreground.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-xxhdpi/ic_launcher_foreground.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-xxhdpi/ic_launcher_foreground.webp -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-xxxhdpi/ic_launcher_foreground.webp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/app/src/main/res/res/mipmap-xxxhdpi/ic_launcher_foreground.webp -------------------------------------------------------------------------------- /app/src/main/res/values/ic_launcher_background.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | #FFFFFF 4 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/capstone_dll.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zh-sc/Skroot-Next/HEAD/patch_kernel_root/3rdparty/capstone-4.0.2-win64/capstone_dll.lib -------------------------------------------------------------------------------- /app/src/main/res/res/values/ic_launcher_background.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | #FFFFFF 4 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/compiler.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/custom.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Custom issue template 3 | about: Describe this issue template's purpose here. 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | 11 | -------------------------------------------------------------------------------- /.idea/kotlinc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/RELEASE_NOTES: -------------------------------------------------------------------------------- 1 | This release 4.0.2 is dedicated to my dad! 2 | 3 | Without him, I would not work in computing field, let alone writing any code 4 | or making contribution to the cyber security community. 5 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | #Mon Jan 20 22:11:26 CST 2025 2 | distributionBase=GRADLE_USER_HOME 3 | distributionPath=wrapper/dists 4 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip 5 | zipStoreBase=GRADLE_USER_HOME 6 | zipStorePath=wrapper/dists 7 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.iml 2 | .gradle 3 | /local.properties 4 | /.idea/caches 5 | /.idea/libraries 6 | /.idea/modules.xml 7 | /.idea/workspace.xml 8 | /.idea/navEditor.xml 9 | /.idea/assetWizardSettings.xml 10 | .DS_Store 11 | /build 12 | /captures 13 | .externalNativeBuild 14 | .cxx 15 | local.properties 16 | -------------------------------------------------------------------------------- /.idea/migrations.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 9 | 10 | -------------------------------------------------------------------------------- /app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-anydpi-v26/ic_launcher.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /app/src/main/res/res/mipmap-anydpi-v26/ic_launcher_round.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /app/src/main/cpp/native-lib.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | extern "C" JNIEXPORT jstring JNICALL 5 | Java_com_linux_skroot_next_MainActivity_stringFromJNI( 6 | JNIEnv* env, 7 | jobject /* this */) { 8 | std::string hello = "Hello from C++"; 9 | return env->NewStringUTF(hello.c_str()); 10 | } -------------------------------------------------------------------------------- /.idea/deploymentTargetSelector.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/include/windowsce/intrin.h: -------------------------------------------------------------------------------- 1 | 2 | #if defined(_MSC_VER) && defined(_WIN32_WCE) && (_WIN32_WCE < 0x800) && !defined(__INTRIN_H_) && !defined(_INTRIN) 3 | #define _STDINT 4 | 5 | #ifdef _M_ARM 6 | #include 7 | #if (_WIN32_WCE >= 0x700) && defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) 8 | #include 9 | #endif 10 | #endif // _M_ARM 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 9 | -------------------------------------------------------------------------------- /app/src/main/res/values/colors.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | #FFBB86FC 4 | #FF6200EE 5 | #FF3700B3 6 | #FF03DAC5 7 | #FF018786 8 | #FF000000 9 | #FFFFFFFF 10 | -------------------------------------------------------------------------------- /app/src/main/res/res/values/colors.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | #FFBB86FC 4 | #FF6200EE 5 | #FF3700B3 6 | #FF03DAC5 7 | #FF018786 8 | #FF000000 9 | #FFFFFFFF 10 | -------------------------------------------------------------------------------- /app/src/test/java/com/linux/skroot/next/ExampleUnitTest.kt: -------------------------------------------------------------------------------- 1 | package com.linux.skroot.next 2 | 3 | import org.junit.Test 4 | 5 | import org.junit.Assert.* 6 | 7 | /** 8 | * Example local unit test, which will execute on the development machine (host). 9 | * 10 | * See [testing documentation](http://d.android.com/tools/testing). 11 | */ 12 | class ExampleUnitTest { 13 | @Test 14 | fun addition_isCorrect() { 15 | assertEquals(4, 2 + 2) 16 | } 17 | } -------------------------------------------------------------------------------- /app/src/main/res/xml/backup_rules.xml: -------------------------------------------------------------------------------- 1 | 8 | 9 | 13 | -------------------------------------------------------------------------------- /app/src/main/res/res/xml/backup_rules.xml: -------------------------------------------------------------------------------- 1 | 8 | 9 | 13 | -------------------------------------------------------------------------------- /patch_kernel_root/kernel_version_parser.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | class KernelVersionParser 5 | { 6 | public: 7 | KernelVersionParser(const std::vector & file_buf); 8 | ~KernelVersionParser(); 9 | 10 | public: 11 | std::string find_kernel_versions(); 12 | bool is_version_less_equal(const std::string& v1, const std::string& v2); 13 | private: 14 | std::string extract_version(const std::vector& buffer, size_t start_index); 15 | std::vector parse_version(const std::string& version); 16 | const std::vector& m_file_buf; 17 | }; -------------------------------------------------------------------------------- /settings.gradle.kts: -------------------------------------------------------------------------------- 1 | pluginManagement { 2 | repositories { 3 | google { 4 | content { 5 | includeGroupByRegex("com\\.android.*") 6 | includeGroupByRegex("com\\.google.*") 7 | includeGroupByRegex("androidx.*") 8 | } 9 | } 10 | mavenCentral() 11 | gradlePluginPortal() 12 | } 13 | } 14 | dependencyResolutionManagement { 15 | repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) 16 | repositories { 17 | google() 18 | mavenCentral() 19 | } 20 | } 21 | 22 | rootProject.name = "Skroot Next" 23 | include(":app") 24 | -------------------------------------------------------------------------------- /app/src/main/res/xml/data_extraction_rules.xml: -------------------------------------------------------------------------------- 1 | 6 | 7 | 8 | 12 | 13 | 19 | -------------------------------------------------------------------------------- /app/src/main/res/res/xml/data_extraction_rules.xml: -------------------------------------------------------------------------------- 1 | 6 | 7 | 8 | 12 | 13 | 19 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/feature_request.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Feature request 3 | about: Suggest an idea for this project 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Is your feature request related to a problem? Please describe.** 11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] 12 | 13 | **Describe the solution you'd like** 14 | A clear and concise description of what you want to happen. 15 | 16 | **Describe alternatives you've considered** 17 | A clear and concise description of any alternative solutions or features you've considered. 18 | 19 | **Additional context** 20 | Add any other context or screenshots about the feature request here. 21 | -------------------------------------------------------------------------------- /app/src/androidTest/java/com/linux/skroot/next/ExampleInstrumentedTest.kt: -------------------------------------------------------------------------------- 1 | package com.linux.skroot.next 2 | 3 | import androidx.test.platform.app.InstrumentationRegistry 4 | import androidx.test.ext.junit.runners.AndroidJUnit4 5 | 6 | import org.junit.Test 7 | import org.junit.runner.RunWith 8 | 9 | import org.junit.Assert.* 10 | 11 | /** 12 | * Instrumented test, which will execute on an Android device. 13 | * 14 | * See [testing documentation](http://d.android.com/tools/testing). 15 | */ 16 | @RunWith(AndroidJUnit4::class) 17 | class ExampleInstrumentedTest { 18 | @Test 19 | fun useAppContext() { 20 | // Context of the app under test. 21 | val appContext = InstrumentationRegistry.getInstrumentation().targetContext 22 | assertEquals("com.linux.skroot.next", appContext.packageName) 23 | } 24 | } -------------------------------------------------------------------------------- /.idea/gradle.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 19 | 20 | -------------------------------------------------------------------------------- /app/proguard-rules.pro: -------------------------------------------------------------------------------- 1 | # Add project specific ProGuard rules here. 2 | # You can control the set of applied configuration files using the 3 | # proguardFiles setting in build.gradle. 4 | # 5 | # For more details, see 6 | # http://developer.android.com/guide/developing/tools/proguard.html 7 | 8 | # If your project uses WebView with JS, uncomment the following 9 | # and specify the fully qualified class name to the JavaScript interface 10 | # class: 11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview { 12 | # public *; 13 | #} 14 | 15 | # Uncomment this to preserve the line number information for 16 | # debugging stack traces. 17 | #-keepattributes SourceFile,LineNumberTable 18 | 19 | # If you keep the line number information, uncomment this to 20 | # hide the original source file name. 21 | #-renamesourcefileattribute SourceFile -------------------------------------------------------------------------------- /patch_kernel_root/kernel_symbol_parser.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "kernel_version_parser.h" 3 | #include "kallsyms_lookup_name.h" 4 | #include "kallsyms_lookup_name_4_6_0.h" 5 | #include "kallsyms_lookup_name_6_1_42.h" 6 | #include 7 | #include 8 | class KernelSymbolParser 9 | { 10 | public: 11 | KernelSymbolParser(const std::vector& file_buf); 12 | ~KernelSymbolParser(); 13 | 14 | public: 15 | bool init_kallsyms_lookup_name(); 16 | uint64_t kallsyms_lookup_name(const char* name, bool include_str_mode = false); 17 | bool is_kernel_version_less_equal(const std::string& ver); 18 | private: 19 | const std::vector& m_file_buf; 20 | KernelVersionParser m_kernel_ver_parser; 21 | KallsymsLookupName m_kallsyms_lookup_name; 22 | KallsymsLookupName_4_6_0 m_kallsyms_lookup_name_4_6_0; 23 | KallsymsLookupName_6_1_42 m_kallsyms_lookup_name_6_1_42; 24 | }; -------------------------------------------------------------------------------- /app/src/main/res/values/themes.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 16 | -------------------------------------------------------------------------------- /app/src/main/res/res/values/themes.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 16 | -------------------------------------------------------------------------------- /app/src/main/res/values-night/themes.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 16 | -------------------------------------------------------------------------------- /app/src/main/res/res/values-night/themes.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 16 | -------------------------------------------------------------------------------- /app/src/main/res/layout/activity_main.xml: -------------------------------------------------------------------------------- 1 | 2 | 8 | 9 | 18 | 19 | -------------------------------------------------------------------------------- /app/src/main/res/res/layout/activity_main.xml: -------------------------------------------------------------------------------- 1 | 2 | 8 | 9 | 18 | 19 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/bug_report.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: Create a report to help us improve 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Describe the bug** 11 | A clear and concise description of what the bug is. 12 | 13 | **To Reproduce** 14 | Steps to reproduce the behavior: 15 | 1. Go to '...' 16 | 2. Click on '....' 17 | 3. Scroll down to '....' 18 | 4. See error 19 | 20 | **Expected behavior** 21 | A clear and concise description of what you expected to happen. 22 | 23 | **Screenshots** 24 | If applicable, add screenshots to help explain your problem. 25 | 26 | **Desktop (please complete the following information):** 27 | - OS: [e.g. iOS] 28 | - Browser [e.g. chrome, safari] 29 | - Version [e.g. 22] 30 | 31 | **Smartphone (please complete the following information):** 32 | - Device: [e.g. iPhone6] 33 | - OS: [e.g. iOS8.1] 34 | - Browser [e.g. stock browser, safari] 35 | - Version [e.g. 22] 36 | 37 | **Additional context** 38 | Add any other context about the problem here. 39 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/SPONSORS.TXT: -------------------------------------------------------------------------------- 1 | * Version 4.0.2 - May 08th, 2020 2 | 3 | Release 4.0.2 was sponsored by the following companies (in no particular order). 4 | 5 | - Senrio: https://senr.io 6 | - Catena Cyber: https://catenacyber.fr 7 | 8 | ------------------------------------ 9 | 10 | * Version 4.0.1 - January 10th, 2019 11 | 12 | Release 4.0.1 was sponsored by the following companies (in no particular order). 13 | 14 | - NowSecure: https://www.nowsecure.com 15 | - Verichains: https://verichains.io 16 | - Vsec: https://vsec.com.vn 17 | 18 | ----------------------------------- 19 | * Version 4.0 - December 18th, 2018 20 | 21 | Capstone 4.0 version marks 5 years of the project! 22 | This release was sponsored by the following companies (in no particular order). 23 | 24 | - Thinkst Canary: https://canary.tools 25 | - NowSecure: https://www.nowsecure.com 26 | - ECQ: https://e-cq.net 27 | - Senrio: https://senr.io 28 | - GracefulBits: https://gracefulbits.com 29 | - Catena Cyber: https://catenacyber.fr 30 | -------------------------------------------------------------------------------- /.idea/runConfigurations.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 16 | 17 | -------------------------------------------------------------------------------- /app/src/main/AndroidManifest.xml: -------------------------------------------------------------------------------- 1 | 2 | 4 | 5 | 15 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /app/src/main/java/com/linux/skroot/next/MainActivity.kt: -------------------------------------------------------------------------------- 1 | package com.linux.skroot.next 2 | 3 | import androidx.appcompat.app.AppCompatActivity 4 | import android.os.Bundle 5 | import android.widget.TextView 6 | import com.linux.skroot.next.databinding.ActivityMainBinding 7 | 8 | class MainActivity : AppCompatActivity() { 9 | 10 | private lateinit var binding: ActivityMainBinding 11 | 12 | override fun onCreate(savedInstanceState: Bundle?) { 13 | super.onCreate(savedInstanceState) 14 | 15 | binding = ActivityMainBinding.inflate(layoutInflater) 16 | setContentView(binding.root) 17 | 18 | // Example of a call to a native method 19 | binding.sampleText.text = stringFromJNI() 20 | } 21 | 22 | /** 23 | * A native method that is implemented by the 'next' native library, 24 | * which is packaged with this application. 25 | */ 26 | external fun stringFromJNI(): String 27 | 28 | companion object { 29 | // Used to load the 'next' library on application startup. 30 | init { 31 | System.loadLibrary("next") 32 | } 33 | } 34 | } -------------------------------------------------------------------------------- /gradle/libs.versions.toml: -------------------------------------------------------------------------------- 1 | [versions] 2 | agp = "8.8.0" 3 | kotlin = "1.9.24" 4 | coreKtx = "1.15.0" 5 | junit = "4.13.2" 6 | junitVersion = "1.2.1" 7 | espressoCore = "3.6.1" 8 | appcompat = "1.7.0" 9 | material = "1.12.0" 10 | constraintlayout = "2.2.0" 11 | 12 | [libraries] 13 | androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" } 14 | junit = { group = "junit", name = "junit", version.ref = "junit" } 15 | androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" } 16 | androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" } 17 | androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" } 18 | material = { group = "com.google.android.material", name = "material", version.ref = "material" } 19 | androidx-constraintlayout = { group = "androidx.constraintlayout", name = "constraintlayout", version.ref = "constraintlayout" } 20 | 21 | [plugins] 22 | android-application = { id = "com.android.application", version.ref = "agp" } 23 | kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" } 24 | 25 | -------------------------------------------------------------------------------- /patch_kernel_root/analyze_kernel.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "kernel_symbol_parser.h" 3 | #include 4 | #include 5 | 6 | struct KernelSymbolOffset { 7 | size_t _text_offset = 0; 8 | size_t _stext_offset = 0; 9 | size_t panic_offset = 0; 10 | 11 | size_t __do_execve_file_offset = 0; 12 | size_t do_execveat_common_offset = 0; 13 | size_t do_execve_common_offset = 0; 14 | size_t do_execveat_offset = 0; 15 | size_t do_execve_offset = 0; 16 | 17 | size_t avc_denied_offset = 0; 18 | size_t revert_creds_offset = 0; 19 | size_t prctl_get_seccomp_offset = 0; 20 | size_t __cfi_check_offset = 0; 21 | size_t __cfi_check_fail_offset = 0; 22 | size_t __cfi_slowpath_diag_offset = 0; 23 | size_t __cfi_slowpath_offset = 0; 24 | size_t __ubsan_handle_cfi_check_fail_abort_offset = 0; 25 | size_t __ubsan_handle_cfi_check_fail_offset = 0; 26 | size_t report_cfi_failure_offset = 0; 27 | }; 28 | 29 | class AnalyzeKernel 30 | { 31 | public: 32 | AnalyzeKernel(const std::vector & file_buf); 33 | ~AnalyzeKernel(); 34 | 35 | public: 36 | bool analyze_kernel_symbol(); 37 | KernelSymbolOffset get_symbol_offset(); 38 | bool is_kernel_version_less_equal(const std::string& ver); 39 | private: 40 | bool find_symbol_offset(); 41 | const std::vector& m_file_buf; 42 | KernelSymbolParser m_kernel_sym_parser; 43 | KernelSymbolOffset m_kernel_sym_offset; 44 | }; -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | # Project-wide Gradle settings. 2 | # IDE (e.g. Android Studio) users: 3 | # Gradle settings configured through the IDE *will override* 4 | # any settings specified in this file. 5 | # For more details on how to configure your build environment visit 6 | # http://www.gradle.org/docs/current/userguide/build_environment.html 7 | # Specifies the JVM arguments used for the daemon process. 8 | # The setting is particularly useful for tweaking memory settings. 9 | org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8 10 | # When configured, Gradle will run in incubating parallel mode. 11 | # This option should only be used with decoupled projects. For more details, visit 12 | # https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects 13 | # org.gradle.parallel=true 14 | # AndroidX package structure to make it clearer which packages are bundled with the 15 | # Android operating system, and which are packaged with your app's APK 16 | # https://developer.android.com/topic/libraries/support-library/androidx-rn 17 | android.useAndroidX=true 18 | # Kotlin code style for this project: "official" or "obsolete": 19 | kotlin.code.style=official 20 | # Enables namespacing of each library's R class so that its R class includes only the 21 | # resources declared in the library itself and none from the library's dependencies, 22 | # thereby reducing the size of the R class for that library 23 | android.nonTransitiveRClass=true -------------------------------------------------------------------------------- /app/build.gradle.kts: -------------------------------------------------------------------------------- 1 | plugins { 2 | alias(libs.plugins.android.application) 3 | alias(libs.plugins.kotlin.android) 4 | } 5 | 6 | android { 7 | namespace = "com.linux.skroot.next" 8 | compileSdk = 35 9 | 10 | defaultConfig { 11 | applicationId = "com.linux.skroot.next" 12 | minSdk = 35 13 | targetSdk = 35 14 | versionCode = 1 15 | versionName = "1.0" 16 | 17 | testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" 18 | externalNativeBuild { 19 | cmake { 20 | cppFlags += "-std=c++17" 21 | } 22 | } 23 | } 24 | 25 | buildTypes { 26 | release { 27 | isMinifyEnabled = false 28 | proguardFiles( 29 | getDefaultProguardFile("proguard-android-optimize.txt"), 30 | "proguard-rules.pro" 31 | ) 32 | } 33 | } 34 | compileOptions { 35 | sourceCompatibility = JavaVersion.VERSION_11 36 | targetCompatibility = JavaVersion.VERSION_11 37 | } 38 | kotlinOptions { 39 | jvmTarget = "11" 40 | } 41 | externalNativeBuild { 42 | cmake { 43 | path = file("src/main/cpp/CMakeLists.txt") 44 | version = "3.22.1" 45 | } 46 | } 47 | buildFeatures { 48 | viewBinding = true 49 | } 50 | } 51 | 52 | dependencies { 53 | 54 | implementation(libs.androidx.core.ktx) 55 | implementation(libs.androidx.appcompat) 56 | implementation(libs.material) 57 | implementation(libs.androidx.constraintlayout) 58 | testImplementation(libs.junit) 59 | androidTestImplementation(libs.androidx.junit) 60 | androidTestImplementation(libs.androidx.espresso.core) 61 | } -------------------------------------------------------------------------------- /app/src/main/res/drawable/ic_launcher_foreground.xml: -------------------------------------------------------------------------------- 1 | 7 | 8 | 9 | 15 | 18 | 21 | 22 | 23 | 24 | 30 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/LICENSE.TXT: -------------------------------------------------------------------------------- 1 | This is the software license for Capstone disassembly framework. 2 | Capstone has been designed & implemented by Nguyen Anh Quynh 3 | 4 | See http://www.capstone-engine.org for further information. 5 | 6 | Copyright (c) 2013, COSEINC. 7 | All rights reserved. 8 | 9 | Redistribution and use in source and binary forms, with or without 10 | modification, are permitted provided that the following conditions are met: 11 | 12 | * Redistributions of source code must retain the above copyright notice, 13 | this list of conditions and the following disclaimer. 14 | * Redistributions in binary form must reproduce the above copyright notice, 15 | this list of conditions and the following disclaimer in the documentation 16 | and/or other materials provided with the distribution. 17 | * Neither the name of the developer(s) nor the names of its 18 | contributors may be used to endorse or promote products derived from this 19 | software without specific prior written permission. 20 | 21 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 22 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 25 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 | POSSIBILITY OF SUCH DAMAGE. 32 | -------------------------------------------------------------------------------- /app/src/main/res/res/drawable/ic_launcher_foreground.xml: -------------------------------------------------------------------------------- 1 | 7 | 8 | 9 | 15 | 18 | 21 | 22 | 23 | 24 | 30 | -------------------------------------------------------------------------------- /app/src/main/cpp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # For more information about using CMake with Android Studio, read the 2 | # documentation: https://d.android.com/studio/projects/add-native-code.html. 3 | # For more examples on how to use CMake, see https://github.com/android/ndk-samples. 4 | 5 | # Sets the minimum CMake version required for this project. 6 | cmake_minimum_required(VERSION 3.22.1) 7 | 8 | # Declares the project name. The project name can be accessed via ${ PROJECT_NAME}, 9 | # Since this is the top level CMakeLists.txt, the project name is also accessible 10 | # with ${CMAKE_PROJECT_NAME} (both CMake variables are in-sync within the top level 11 | # build script scope). 12 | project("next") 13 | 14 | # Creates and names a library, sets it as either STATIC 15 | # or SHARED, and provides the relative paths to its source code. 16 | # You can define multiple libraries, and CMake builds them for you. 17 | # Gradle automatically packages shared libraries with your APK. 18 | # 19 | # In this top level CMakeLists.txt, ${CMAKE_PROJECT_NAME} is used to define 20 | # the target library name; in the sub-module's CMakeLists.txt, ${PROJECT_NAME} 21 | # is preferred for the same purpose. 22 | # 23 | # In order to load a library into your app from Java/Kotlin, you must call 24 | # System.loadLibrary() and pass the name of the library defined here; 25 | # for GameActivity/NativeActivity derived applications, the same library name must be 26 | # used in the AndroidManifest.xml file. 27 | add_library(${CMAKE_PROJECT_NAME} SHARED 28 | # List C/C++ source files with relative paths to this CMakeLists.txt. 29 | native-lib.cpp) 30 | 31 | # Specifies libraries CMake should link to your target library. You 32 | # can link libraries from various origins, such as libraries defined in this 33 | # build script, prebuilt third-party libraries, or Android system libraries. 34 | target_link_libraries(${CMAKE_PROJECT_NAME} 35 | # List libraries link to the target library 36 | android 37 | log) -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |
2 | logo 3 |

Skroot-Next

4 | 5 | [![Latest Release](https://img.shields.io/github/v/release/zh-sc/Skroot-Next?label=Release&logo=github)](https://github.com/zh-sc/Skroot-Next/releases/latest) 6 | [![Channel](https://img.shields.io/badge/Follow-Telegram-blue.svg?logo=telegram)](https://t.me/Skroot_Next) 7 | 8 |
9 | 10 | ## 介绍 11 | ## SKRoot-Next - Super Kernel Root 12 | - 全网无root检测手段，跟面具完全不同思路. 13 | 14 | - 摆脱面具被检测的弱点，完美隐藏root功能 15 | - 全程不需要暂停SELinux，实现真正的SELinux 0%触碰. 16 | - 通用性强，通杀所有内核，不需要内核源码 17 | - 直接patch内核，兼容安卓APP直接JNI调用，稳定、流畅、不闪退。 18 | - Android Linux内核 Android 系统补丁。 19 | - Skroot-Next依赖于 [Skroot](https://github.com/bmax121/KernelPatch/). 20 | - Skroot UI 和 APModule 源代码是从 KernelSU 和Skroot 参考和修改的。 21 | - [KernelSU](https://github.com/tiann/KernelSU).[Skroot](https://github.com/abcz316/SKRoot-linuxKernelRoot) 22 | 23 | ## 支持版本 24 | 仅支持 ARM64 架构。 25 | 26 | 仅支持 Android 内核版本 3.x - 6.1 27 | ## 要求 28 | 29 | 内核配置: 30 | 31 | - `所有Android Linux 内核配置都完全支持 32 | 33 | ## 危险警告 34 | 35 | - 48位SuperKey 具有比 root 访问权限更高的权限。 36 | 37 | - 密钥保护它们不被暴露以维护设备的安全性至关重要。 38 | 39 | ## 下载 40 | [Github](https://github.com/zh-sc/Skroot-Next) 41 | 42 | ## Get Help | 获得帮助 43 | 44 | ### 用法 45 | - 请记住48位密钥，这是你的唯一凭证 46 | - 可以去看skroot[文献内容](https://github.com/abcz316/SKRoot-linuxKernelRoot/blob/master/README.md) 47 | ### 更新 48 | 49 | - Telegram Channel | 官方电报: [@Skroot-next](https://t.me/Skroot_Next) 50 | 51 | ### 讨论 52 | 53 | - Telegram Group | 电报群: [@交流群](https://t.me/skroot_Next_chat) 54 | 55 | ### 更多内容 56 | 57 | - [查看](https://github.com/abcz316/SKRoot-linuxKernelRoot/blob/master/README.md) 58 | 59 | ## 学习 60 | 61 | - [KernelPatch](https://github.com/abcz316/SKRoot-linuxKernelRoot): 参考核心 62 | - [Magisk](https://github.com/topjohnwu/Magisk): 参考自动化修订boot脚本 63 | - [KernelSU](https://github.com/tiann/KernelSU): 参考App UI 和Linux内核之类的支持 64 | - [APatch](https://github.com/bmax121/APatch):参考su运作方式 65 | ## 许可证 66 | 67 | Skroot-Next根据 GNU 通用公共许可证 v3[GPL-3](http://www.gnu.org/copyleft/gpl.html). 68 | -------------------------------------------------------------------------------- /patch_kernel_root/base_func.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | static std::vector read_file_buf(const std::string& file_path) { 11 | std::ifstream file(file_path, std::ios::binary | std::ios::ate); 12 | if (file) { 13 | auto size = file.tellg(); 14 | std::vector buffer(size); 15 | file.seekg(0, std::ios::beg); 16 | file.read(buffer.data(), size); 17 | file.close(); 18 | return buffer; 19 | } 20 | return {}; 21 | } 22 | 23 | static void get_rand_str(char* dest, int n) { 24 | int i, randno; 25 | char stardstring[63] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; 26 | srand((unsigned)time(NULL)); 27 | for (i = 0; i < n; i++) { 28 | randno = rand() % 62; 29 | *dest = stardstring[randno]; 30 | dest++; 31 | } 32 | } 33 | 34 | static std::string generate_random_root_key() { 35 | const int key_len = 48; 36 | char root_key_data[key_len] = { 0 }; 37 | get_rand_str(root_key_data, sizeof(root_key_data)); 38 | std::string str_root_key(root_key_data, sizeof(root_key_data)); 39 | return str_root_key; 40 | } 41 | 42 | static auto hex2byte(uint8_t* hex, uint8_t* str) -> void { 43 | char high, low; 44 | for (size_t i = 0, length = strlen((char*)hex); i < length; i += 2) { 45 | high = toupper(hex[i]) - '0'; 46 | low = toupper(hex[i + 1]) - '0'; 47 | str[i / 2] = ((high > 9 ? high - 7 : high) << 4) + (low > 9 ? low - 7 : low); 48 | } 49 | } 50 | 51 | static bool write_file_bytes(const char* file_path, size_t offset, const char* bytes, size_t len) { 52 | std::fstream file_stream(file_path, std::ios::in | std::ios::out | std::ios::binary); 53 | if (!file_stream) { 54 | return false; 55 | } 56 | file_stream.seekp(offset); 57 | if (!file_stream.good()) { 58 | file_stream.close(); 59 | return false; 60 | } 61 | file_stream.write(bytes, len); 62 | if (!file_stream.good()) { 63 | file_stream.close(); 64 | return false; 65 | } 66 | file_stream.close(); 67 | return true; 68 | } 69 | 70 | static size_t align8(size_t addr) { 71 | if (addr % 8 != 0) { 72 | addr = (addr + 7) & ~static_cast(7); // Align to next 8-byte boundary 73 | } 74 | return addr; 75 | } 76 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/README.md: -------------------------------------------------------------------------------- 1 | Capstone Engine 2 | =============== 3 | 4 | [![Build Status](https://travis-ci.org/aquynh/capstone.svg?branch=v4)](https://travis-ci.org/aquynh/capstone) 5 | [![Build status](https://ci.appveyor.com/api/projects/status/a4wvbn89wu3pinas/branch/v4?svg=true)](https://ci.appveyor.com/project/aquynh/capstone/branch/v4) 6 | 7 | Capstone is a disassembly framework with the target of becoming the ultimate 8 | disasm engine for binary analysis and reversing in the security community. 9 | 10 | Created by Nguyen Anh Quynh, then developed and maintained by a small community, 11 | Capstone offers some unparalleled features: 12 | 13 | - Support multiple hardware architectures: ARM, ARM64 (ARMv8), Ethereum VM, M68K, 14 | Mips, PPC, Sparc, SystemZ, TMS320C64X, M680X, XCore and X86 (including X86_64). 15 | 16 | - Having clean/simple/lightweight/intuitive architecture-neutral API. 17 | 18 | - Provide details on disassembled instruction (called “decomposer” by others). 19 | 20 | - Provide semantics of the disassembled instruction, such as list of implicit 21 | registers read & written. 22 | 23 | - Implemented in pure C language, with lightweight bindings for D, Clojure, F#, 24 | Common Lisp, Visual Basic, PHP, PowerShell, Emacs, Haskell, Perl, Python, 25 | Ruby, C#, NodeJS, Java, GO, C++, OCaml, Lua, Rust, Delphi, Free Pascal & Vala 26 | (ready either in main code, or provided externally by the community). 27 | 28 | - Native support for all popular platforms: Windows, Mac OSX, iOS, Android, 29 | Linux, \*BSD, Solaris, etc. 30 | 31 | - Thread-safe by design. 32 | 33 | - Special support for embedding into firmware or OS kernel. 34 | 35 | - High performance & suitable for malware analysis (capable of handling various 36 | X86 malware tricks). 37 | 38 | - Distributed under the open source BSD license. 39 | 40 | Further information is available at http://www.capstone-engine.org 41 | 42 | 43 | Compile 44 | ------- 45 | 46 | See COMPILE.TXT file for how to compile and install Capstone. 47 | 48 | 49 | Documentation 50 | ------------- 51 | 52 | See docs/README for how to customize & program your own tools with Capstone. 53 | 54 | 55 | Hack 56 | ---- 57 | 58 | See HACK.TXT file for the structure of the source code. 59 | 60 | 61 | License 62 | ------- 63 | 64 | This project is released under the BSD license. If you redistribute the binary 65 | or source code of Capstone, please attach file LICENSE.TXT with your products. 66 | -------------------------------------------------------------------------------- /patch_kernel_root/kernel_version_parser.cpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "kernel_version_parser.h" 3 | #include 4 | 5 | #ifndef MIN 6 | #define MIN(x, y)(x < y) ? (x) : (y) 7 | #endif // !MIN 8 | 9 | KernelVersionParser::KernelVersionParser(const std::vector& file_buf) : m_file_buf(file_buf) 10 | { 11 | } 12 | 13 | KernelVersionParser::~KernelVersionParser() 14 | { 15 | } 16 | 17 | // Helper function to extract and print the version number starting from the given index 18 | std::string KernelVersionParser::extract_version(const std::vector& buffer, size_t start_index) { 19 | std::string version; 20 | // Extract until we hit a non-version character or end of buffer 21 | while (start_index < buffer.size() && (isdigit(buffer[start_index]) || buffer[start_index] == '.')) { 22 | version.push_back(buffer[start_index]); 23 | ++start_index; 24 | } 25 | return version; 26 | } 27 | 28 | // Function to search for Linux version patterns using memcmp 29 | std::string KernelVersionParser::find_kernel_versions() { 30 | const size_t safe_end = MIN(m_file_buf.size(), 256); 31 | const char* prefix = "Linux version "; 32 | const size_t prefix_len = strlen(prefix); 33 | 34 | for (size_t i = 0; i + prefix_len <= m_file_buf.size() - safe_end; ++i) { 35 | if (memcmp(m_file_buf.data() + i, prefix, prefix_len) == 0 && isdigit(m_file_buf[i + prefix_len])) { 36 | return extract_version(m_file_buf, i + prefix_len); 37 | } 38 | } 39 | return {}; 40 | } 41 | 42 | 43 | // Helper function to split the version string and convert to integers 44 | std::vector KernelVersionParser::parse_version(const std::string& version) { 45 | std::vector parts; 46 | std::stringstream ss(version); 47 | std::string part; 48 | 49 | while (getline(ss, part, '.')) { 50 | parts.push_back(std::stoi(part)); 51 | } 52 | // Ensure we always have at least three parts (fill missing parts with zero) 53 | while (parts.size() < 3) { 54 | parts.push_back(0); 55 | } 56 | 57 | return parts; 58 | } 59 | 60 | // Function to compare two version numbers 61 | bool KernelVersionParser::is_version_less_equal(const std::string& v1, const std::string& v2) { 62 | auto parts1 = parse_version(v1); 63 | auto parts2 = parse_version(v2); 64 | 65 | // Compare major, minor, and patch versions 66 | for (int i = 0; i < 3; ++i) { 67 | if (parts1[i] < parts2[i]) return true; 68 | if (parts1[i] > parts2[i]) return false; 69 | } 70 | 71 | // If all parts are equal 72 | return true; 73 | } 74 | -------------------------------------------------------------------------------- /patch_kernel_root/kernel_symbol_parser.cpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "kernel_symbol_parser.h" 3 | #include 4 | 5 | #ifndef MIN 6 | #define MIN(x, y)(x < y) ? (x) : (y) 7 | #endif // !MIN 8 | 9 | KernelSymbolParser::KernelSymbolParser(const std::vector& file_buf) : m_file_buf(file_buf), m_kernel_ver_parser(file_buf), m_kallsyms_lookup_name_6_1_42(file_buf), m_kallsyms_lookup_name_4_6_0(file_buf), m_kallsyms_lookup_name(file_buf) 10 | { 11 | } 12 | 13 | KernelSymbolParser::~KernelSymbolParser() 14 | { 15 | } 16 | 17 | bool KernelSymbolParser::init_kallsyms_lookup_name() { 18 | 19 | std::string current_version = m_kernel_ver_parser.find_kernel_versions(); 20 | if (current_version.empty()) { 21 | std::cout << "Failed to read Linux kernel version" << std::endl; 22 | return false; 23 | } 24 | std::cout << "Find the current Linux kernel version: " << current_version << std::endl; 25 | std::cout << std::endl; 26 | 27 | if (m_kernel_ver_parser.is_version_less_equal(current_version, "4.6.0")) { 28 | if (!m_kallsyms_lookup_name.init()) { 29 | std::cout << "Failed to analyze kernel kallsyms lookup name information" << std::endl; 30 | return false; 31 | } 32 | } else if (m_kernel_ver_parser.is_version_less_equal(current_version, "6.1.42")) { 33 | if (!m_kallsyms_lookup_name_4_6_0.init()) { 34 | std::cout << "Failed to analyze kernel kallsyms lookup name information" << std::endl; 35 | return false; 36 | } 37 | } else { 38 | if (!m_kallsyms_lookup_name_6_1_42.init()) { 39 | std::cout << "Failed to analyze kernel kallsyms lookup name information" << std::endl; 40 | return false; 41 | } 42 | } 43 | return true; 44 | } 45 | 46 | uint64_t KernelSymbolParser::kallsyms_lookup_name(const char* name, bool include_str_mode) { 47 | if (m_kallsyms_lookup_name_6_1_42.is_inited()) { 48 | return m_kallsyms_lookup_name_6_1_42.kallsyms_lookup_name(name, include_str_mode); 49 | } else if (m_kallsyms_lookup_name_4_6_0.is_inited()) { 50 | return m_kallsyms_lookup_name_4_6_0.kallsyms_lookup_name(name, include_str_mode); 51 | } else if (m_kallsyms_lookup_name.is_inited()) { 52 | return m_kallsyms_lookup_name.kallsyms_lookup_name(name, include_str_mode); 53 | } else { 54 | return 0; 55 | } 56 | } 57 | 58 | bool KernelSymbolParser::is_kernel_version_less_equal(const std::string& ver) { 59 | std::string current_version = m_kernel_ver_parser.find_kernel_versions(); 60 | if (!current_version.empty()) { 61 | return m_kernel_ver_parser.is_version_less_equal(current_version, ver); 62 | } 63 | return false; 64 | } 65 | -------------------------------------------------------------------------------- /patch_kernel_root/kallsyms_lookup_name_4_6_0.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | class KallsymsLookupName_4_6_0 5 | { 6 | public: 7 | KallsymsLookupName_4_6_0(const std::vector& file_buf); 8 | ~KallsymsLookupName_4_6_0(); 9 | 10 | public: 11 | bool init(); 12 | bool is_inited(); 13 | uint64_t kallsyms_lookup_name(const char* name, bool include_str_mode = false); 14 | int get_kallsyms_num(); 15 | 16 | private: 17 | bool find_kallsyms_offsets_list(size_t& start, size_t& end); 18 | int find_kallsyms_num(size_t offset_list_start, size_t offset_list_end, size_t& kallsyms_num_offset); 19 | bool find_kallsyms_names_list(int kallsyms_num, size_t kallsyms_num_end_offset, size_t& name_list_start, size_t& name_list_end); 20 | bool find_kallsyms_markers_list(int kallsyms_num, size_t name_list_end_offset, size_t& markers_list_start, size_t& markers_list_end); 21 | bool find_kallsyms_token_table(size_t markers_list_end_offset, size_t& kallsyms_token_table_start, size_t& kallsyms_token_table_end); 22 | bool find_kallsyms_token_index(size_t kallsyms_token_table_end, size_t& kallsyms_token_index_start); 23 | bool find_kallsyms_sym_func_entry_offset(size_t& kallsyms_sym_func_entry_offset); 24 | 25 | unsigned int kallsyms_expand_symbol(unsigned int off, char* result, size_t maxlen); 26 | uint64_t __kallsyms_lookup_name(const char* name, bool include_str_mode = false); 27 | 28 | const std::vector& m_file_buf; 29 | int m_kallsyms_num = 0; 30 | bool m_inited = false; 31 | size_t m_kallsyms_sym_func_entry_offset = 0; 32 | 33 | struct kallsyms_offsets_info { 34 | size_t offset = 0; 35 | void printf() { 36 | std::cout << std::hex << "kallsyms_offsets offset: 0x" << offset << std::endl; 37 | } 38 | } m_kallsyms_offsets; 39 | 40 | struct kallsyms_names_info { 41 | size_t offset = 0; 42 | void printf() { 43 | std::cout << std::hex << "kallsyms_names offset: 0x" << offset << std::endl; 44 | } 45 | } m_kallsyms_names; 46 | 47 | struct kallsyms_markers_info { 48 | size_t offset = 0; 49 | void printf() { 50 | std::cout << std::hex << "kallsyms_markers offset: 0x" << offset << std::endl; 51 | } 52 | } m_kallsyms_markers; 53 | 54 | struct kallsyms_token_table_info { 55 | size_t offset = 0; 56 | void printf() { 57 | std::cout << std::hex << "kallsyms_token_table offset: 0x" << offset << std::endl; 58 | } 59 | } m_kallsyms_token_table; 60 | 61 | struct kallsyms_token_index_info { 62 | size_t offset = 0; 63 | void printf() { 64 | std::cout << std::hex << "kallsyms_token_index offset: 0x" << offset << std::endl; 65 | } 66 | } m_kallsyms_token_index; 67 | }; -------------------------------------------------------------------------------- /patch_kernel_root/kallsyms_lookup_name.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | class KallsymsLookupName 5 | { 6 | public: 7 | KallsymsLookupName(const std::vector& file_buf); 8 | ~KallsymsLookupName(); 9 | 10 | public: 11 | bool init(); 12 | bool is_inited(); 13 | uint64_t kallsyms_lookup_name(const char* name, bool include_str_mode = false); 14 | int get_kallsyms_num(); 15 | 16 | private: 17 | bool find_kallsyms_addresses_list(size_t& start, size_t& end); 18 | int find_kallsyms_num(size_t addresses_list_start, size_t addresses_list_end, size_t& kallsyms_num_offset); 19 | bool find_kallsyms_names_list(int kallsyms_num, size_t kallsyms_num_end_offset, size_t& name_list_start, size_t& name_list_end); 20 | bool find_kallsyms_markers_list(int kallsyms_num, size_t name_list_end_offset, size_t& markers_list_start, size_t& markers_list_end); 21 | bool find_kallsyms_token_table(size_t markers_list_end_offset, size_t& kallsyms_token_table_start, size_t& kallsyms_token_table_end); 22 | bool find_kallsyms_token_index(size_t kallsyms_token_table_end, size_t& kallsyms_token_index_start); 23 | bool find_kallsyms_sym_func_entry_offset(size_t& kallsyms_sym_func_entry_offset); 24 | 25 | unsigned int kallsyms_expand_symbol(unsigned int off, char* result, size_t maxlen); 26 | uint64_t __kallsyms_lookup_name(const char* name, bool include_str_mode = false); 27 | 28 | const std::vector& m_file_buf; 29 | int m_kallsyms_num = 0; 30 | bool m_inited = false; 31 | size_t m_kallsyms_sym_func_entry_offset = 0; 32 | size_t m_text_offset = 0; 33 | struct kallsyms_addresses_info { 34 | size_t offset = 0; 35 | void printf() { 36 | std::cout << std::hex << "kallsyms_addressess offset: 0x" << offset << std::endl; 37 | } 38 | } m_kallsyms_addresses; 39 | 40 | struct kallsyms_names_info { 41 | size_t offset = 0; 42 | void printf() { 43 | std::cout << std::hex << "kallsyms_names offset: 0x" << offset << std::endl; 44 | } 45 | } m_kallsyms_names; 46 | 47 | struct kallsyms_markers_info { 48 | size_t offset = 0; 49 | void printf() { 50 | std::cout << std::hex << "kallsyms_markers offset: 0x" << offset << std::endl; 51 | } 52 | } m_kallsyms_markers; 53 | 54 | struct kallsyms_token_table_info { 55 | size_t offset = 0; 56 | void printf() { 57 | std::cout << std::hex << "kallsyms_token_table offset: 0x" << offset << std::endl; 58 | } 59 | } m_kallsyms_token_table; 60 | 61 | struct kallsyms_token_index_info { 62 | size_t offset = 0; 63 | void printf() { 64 | std::cout << std::hex << "kallsyms_token_index offset: 0x" << offset << std::endl; 65 | } 66 | } m_kallsyms_token_index; 67 | }; -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/CREDITS.TXT: -------------------------------------------------------------------------------- 1 | This file credits all the contributors of the Capstone engine project. 2 | 3 | Key developers 4 | ============== 5 | 1. Nguyen Anh Quynh 6 | - Core engine 7 | - Bindings: Python, Ruby, OCaml, Java, C# 8 | 9 | 2. Tan Sheng Di 10 | - Bindings: Ruby 11 | 12 | 3. Ben Nagy 13 | - Bindings: Ruby, Go 14 | 15 | 4. Dang Hoang Vu 16 | - Bindings: Java 17 | 18 | 19 | Beta testers (in random order) 20 | ============================== 21 | Pancake 22 | Van Hauser 23 | FX of Phenoelit 24 | The Grugq, The Grugq <-- our hero for submitting the first ever patch! 25 | Isaac Dawson, Veracode Inc 26 | Patroklos Argyroudis, Census Inc. (http://census-labs.com) 27 | Attila Suszter 28 | Le Dinh Long 29 | Nicolas Ruff 30 | Gunther 31 | Alex Ionescu, Winsider Seminars & Solutions Inc. 32 | Snare 33 | Daniel Godas-Lopez 34 | Joshua J. Drake 35 | Edgar Barbosa 36 | Ralf-Philipp Weinmann 37 | Hugo Fortier 38 | Joxean Koret 39 | Bruce Dang 40 | Andrew Dunham 41 | 42 | 43 | Contributors (in no particular order) 44 | ===================================== 45 | (Please let us know if you want to have your name here) 46 | 47 | Ole André Vadla Ravnås (author of the 100th Pull-Request in our Github repo, thanks!) 48 | Axel "0vercl0k" Souchet (@0vercl0k) & Alex Ionescu: port to MSVC. 49 | Daniel Pistelli: Cmake support. 50 | Peter Hlavaty: integrate Capstone for Windows kernel drivers. 51 | Guillaume Jeanne: Ocaml binding. 52 | Martin Tofall, Obsidium Software: Optimize X86 performance & size + x86 encoding features. 53 | David Martínez Moreno & Hilko Bengen: Debian package. 54 | Félix Cloutier: Xcode project. 55 | Benoit Lecocq: OpenBSD package. 56 | Christophe Avoinne (Hlide): Improve memory management for better performance. 57 | Michael Cohen & Nguyen Tan Cong: Python module installer. 58 | Adel Gadllah, Francisco Alonso & Stefan Cornelius: RPM package. 59 | Felix Gröbert (Google): fuzz testing harness. 60 | Xipiter LLC: Capstone logo redesigned. 61 | Satoshi Tanda: Support Windows kernel driver. 62 | Tang Yuhang: cstool. 63 | Andrew Dutcher: better Python setup. 64 | Ruben Boonen: PowerShell binding. 65 | David Zimmer: VB6 binding. 66 | Philippe Antoine: Integration with oss-fuzz and various fixes. 67 | Bui Dinh Cuong: Explicit registers accessed for Arm64. 68 | Vincent Bénony: Explicit registers accessed for X86. 69 | Adel Gadllah, Francisco Alonso & Stefan Cornelius: RPM package. 70 | Felix Gröbert (Google): fuzz testing harness. 71 | Daniel Collin & Nicolas Planel: M68K architecture. 72 | Pranith Kumar: Explicit registers accessed for Arm64. 73 | Xipiter LLC: Capstone logo redesigned. 74 | Satoshi Tanda: Support Windows kernel driver. 75 | Koutheir Attouchi: Support for Windows CE. 76 | Fotis Loukos: TMS320C64x architecture. 77 | Wolfgang Schwotzer: M680X architecture. 78 | Philippe Antoine: Integration with oss-fuzz and various fixes. 79 | Stephen Eckels (stevemk14ebr): x86 encoding features 80 | -------------------------------------------------------------------------------- /patch_kernel_root/ARM_asm.h: -------------------------------------------------------------------------------- 1 | #ifndef ARM_ASM_HELPER_H_ 2 | #define ARM_ASM_HELPER_H_ 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | std::string AsmToBytes(const std::string& strArm64Asm) { 10 | //获取汇编文本 11 | 12 | //获取自身运行目录 13 | char szFileName[MAX_PATH] = { 0 }; 14 | ::GetModuleFileNameA(NULL, szFileName, MAX_PATH); 15 | std::string strMyPath = szFileName; 16 | strMyPath = strMyPath.substr(0, strMyPath.find_last_of('\\') + 1); 17 | 18 | std::string asmFilePath = strMyPath + "aarch64-linux-android-as.exe"; 19 | if (!std::filesystem::exists(asmFilePath)) { 20 | std::cerr << "Error: aarch64-linux-android-as.exe not found. Please extract this file from the Android NDK." << std::endl; 21 | exit(EXIT_FAILURE); 22 | } 23 | 24 | //写出input.txt 25 | std::ofstream inputFile; 26 | inputFile.open(strMyPath + "input.txt", std::ios_base::out | std::ios_base::trunc); 27 | inputFile << strArm64Asm; 28 | inputFile.close(); 29 | 30 | //ARM64 31 | DeleteFileA(std::string(strMyPath + "output.txt").c_str()); 32 | 33 | std::string cmd = strMyPath + "aarch64-linux-android-as.exe -ahlm " + strMyPath + "input.txt >> " + strMyPath + "output.txt"; 34 | system(cmd.c_str()); 35 | 36 | //未开发的 37 | //ARM：arm-linux-as.exe -ahlm -k -mthumb-interwork -march=armv7-a %s >> %s 38 | //Thumb：arm-linux-as.exe -ahlm -k -mthumb-interwork -march=armv7 %s >> %s 39 | 40 | //读取output.txt 41 | std::ifstream in(strMyPath + "output.txt"); 42 | std::stringstream ssOutput; 43 | std::string line; 44 | bool bIsFirstLine = true; 45 | if (in) // 有该文件 46 | { 47 | while (getline(in, line)) // line中不包括每行的换行符 48 | { 49 | if (bIsFirstLine) { 50 | bIsFirstLine = false; 51 | continue; 52 | } 53 | if (!line.length()) { continue; } 54 | if (line.length() == 1 && line == "\n") { continue; } 55 | if (line.find("Error") != -1) { 56 | in.close(); 57 | return {}; 58 | } 59 | if (line.find("AARCH64 GAS") != -1) { continue; } 60 | 61 | std::stringstream ssGetMidBuf; 62 | std::string word; 63 | ssGetMidBuf << line; 64 | int n = 0; 65 | while (ssGetMidBuf >> word) { 66 | n++; 67 | if (n == 3) { 68 | ssOutput << word; 69 | } 70 | word.clear(); 71 | } 72 | 73 | 74 | } 75 | in.close(); 76 | } 77 | 78 | return ssOutput.str(); 79 | 80 | } 81 | 82 | const char HEX[16] = { 83 | '0', '1', '2', '3', 84 | '4', '5', '6', '7', 85 | '8', '9', 'a', 'b', 86 | 'c', 'd', 'e', 'f' 87 | }; 88 | 89 | /* Convert byte array to hex string. */ 90 | std::string bytes_2_hex_str(const unsigned char* input, size_t length) { 91 | 92 | std::string str; 93 | str.reserve(length << 1); 94 | for (size_t i = 0; i < length; ++i) { 95 | int t = input[i]; 96 | int a = t / 16; 97 | int b = t % 16; 98 | str.append(1, HEX[a]); 99 | str.append(1, HEX[b]); 100 | } 101 | return str; 102 | } 103 | 104 | #endif /* ARM_ASM_HELPER_H_ */ 105 | -------------------------------------------------------------------------------- /gradlew.bat: -------------------------------------------------------------------------------- 1 | @rem 2 | @rem Copyright 2015 the original author or authors. 3 | @rem 4 | @rem Licensed under the Apache License, Version 2.0 (the "License"); 5 | @rem you may not use this file except in compliance with the License. 6 | @rem You may obtain a copy of the License at 7 | @rem 8 | @rem https://www.apache.org/licenses/LICENSE-2.0 9 | @rem 10 | @rem Unless required by applicable law or agreed to in writing, software 11 | @rem distributed under the License is distributed on an "AS IS" BASIS, 12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | @rem See the License for the specific language governing permissions and 14 | @rem limitations under the License. 15 | @rem 16 | 17 | @if "%DEBUG%" == "" @echo off 18 | @rem ########################################################################## 19 | @rem 20 | @rem Gradle startup script for Windows 21 | @rem 22 | @rem ########################################################################## 23 | 24 | @rem Set local scope for the variables with windows NT shell 25 | if "%OS%"=="Windows_NT" setlocal 26 | 27 | set DIRNAME=%~dp0 28 | if "%DIRNAME%" == "" set DIRNAME=. 29 | set APP_BASE_NAME=%~n0 30 | set APP_HOME=%DIRNAME% 31 | 32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter. 33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi 34 | 35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" 37 | 38 | @rem Find java.exe 39 | if defined JAVA_HOME goto findJavaFromJavaHome 40 | 41 | set JAVA_EXE=java.exe 42 | %JAVA_EXE% -version >NUL 2>&1 43 | if "%ERRORLEVEL%" == "0" goto execute 44 | 45 | echo. 46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 47 | echo. 48 | echo Please set the JAVA_HOME variable in your environment to match the 49 | echo location of your Java installation. 50 | 51 | goto fail 52 | 53 | :findJavaFromJavaHome 54 | set JAVA_HOME=%JAVA_HOME:"=% 55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe 56 | 57 | if exist "%JAVA_EXE%" goto execute 58 | 59 | echo. 60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 61 | echo. 62 | echo Please set the JAVA_HOME variable in your environment to match the 63 | echo location of your Java installation. 64 | 65 | goto fail 66 | 67 | :execute 68 | @rem Setup the command line 69 | 70 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar 71 | 72 | 73 | @rem Execute Gradle 74 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* 75 | 76 | :end 77 | @rem End local scope for the variables with windows NT shell 78 | if "%ERRORLEVEL%"=="0" goto mainEnd 79 | 80 | :fail 81 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of 82 | rem the _cmd.exe /c_ return code! 83 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 84 | exit /b 1 85 | 86 | :mainEnd 87 | if "%OS%"=="Windows_NT" endlocal 88 | 89 | :omega 90 | -------------------------------------------------------------------------------- /patch_kernel_root/kallsyms_lookup_name_6_1_42.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | class KallsymsLookupName_6_1_42 5 | { 6 | public: 7 | KallsymsLookupName_6_1_42(const std::vector& file_buf); 8 | ~KallsymsLookupName_6_1_42(); 9 | 10 | public: 11 | bool init(); 12 | bool is_inited(); 13 | uint64_t kallsyms_lookup_name(const char* name, bool include_str_mode = false); 14 | int get_kallsyms_num(); 15 | 16 | private: 17 | bool find_kallsyms_offsets_list(size_t& start, size_t& end); 18 | uint64_t find_kallsyms_relative_base(size_t offset_list_end, size_t& kallsyms_relative_base_offset); 19 | int find_kallsyms_num(size_t offset_list_start, size_t offset_list_end, size_t kallsyms_relative_base_end_offset, size_t& kallsyms_num_offset); 20 | bool find_kallsyms_names_list(int kallsyms_num, size_t kallsyms_num_end_offset, size_t& name_list_start, size_t& name_list_end); 21 | bool find_kallsyms_markers_list(int kallsyms_num, size_t name_list_end_offset, size_t& markers_list_start, size_t& markers_list_end, bool & markers_list_is_align8); 22 | bool find_kallsyms_seqs_of_names_list(int kallsyms_num, size_t markers_list_end_offset, bool markers_list_is_align8, size_t& seqs_of_names_list_start, size_t& seqs_of_names_list_end); 23 | bool find_kallsyms_token_table(size_t seqs_of_names_list_end_offset, size_t& kallsyms_token_table_start, size_t& kallsyms_token_table_end); 24 | bool find_kallsyms_token_index(size_t kallsyms_token_table_end, size_t& kallsyms_token_index_start); 25 | bool find_kallsyms_sym_func_entry_offset(size_t& kallsyms_sym_func_entry_offset); 26 | 27 | unsigned int kallsyms_expand_symbol(unsigned int off, char* result, size_t maxlen); 28 | uint64_t __kallsyms_lookup_name(const char* name, bool include_str_mode = false); 29 | int kallsyms_lookup_names(const char* name, unsigned int* start, unsigned int* end); 30 | unsigned int get_symbol_offset(unsigned long pos); 31 | uint64_t kallsyms_sym_address(int idx); 32 | int compare_symbol_name(const char* name, char* namebuf); 33 | bool cleanup_symbol_name(char* s); 34 | 35 | const std::vector& m_file_buf; 36 | uint64_t m_kallsyms_relative_base = 0; 37 | int m_kallsyms_num = 0; 38 | bool m_inited = false; 39 | size_t m_kallsyms_sym_func_entry_offset = 0; 40 | 41 | struct kallsyms_offsets_info { 42 | size_t offset = 0; 43 | void printf() { 44 | std::cout << std::hex << "kallsyms_offsets offset: 0x" << offset << std::endl; 45 | } 46 | } m_kallsyms_offsets; 47 | 48 | struct kallsyms_names_info { 49 | size_t offset = 0; 50 | void printf() { 51 | std::cout << std::hex << "kallsyms_names offset: 0x" << offset << std::endl; 52 | } 53 | } m_kallsyms_names; 54 | 55 | struct kallsyms_markers_info { 56 | size_t offset = 0; 57 | void printf() { 58 | std::cout << std::hex << "kallsyms_markers offset: 0x" << offset << std::endl; 59 | } 60 | } m_kallsyms_markers; 61 | 62 | struct kallsyms_seqs_of_names_info { 63 | size_t offset = 0; 64 | void printf() { 65 | std::cout << std::hex << "kallsyms_seqs_of_names offset: 0x" << offset << std::endl; 66 | } 67 | } m_kallsyms_seqs_of_names; 68 | 69 | struct kallsyms_token_table_info { 70 | size_t offset = 0; 71 | void printf() { 72 | std::cout << std::hex << "kallsyms_token_table offset: 0x" << offset << std::endl; 73 | } 74 | } m_kallsyms_token_table; 75 | 76 | struct kallsyms_token_index_info { 77 | size_t offset = 0; 78 | void printf() { 79 | std::cout << std::hex << "kallsyms_token_index offset: 0x" << offset << std::endl; 80 | } 81 | } m_kallsyms_token_index; 82 | }; -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/LICENSE_LLVM.TXT: -------------------------------------------------------------------------------- 1 | ============================================================================== 2 | LLVM Release License 3 | ============================================================================== 4 | University of Illinois/NCSA 5 | Open Source License 6 | 7 | Copyright (c) 2003-2013 University of Illinois at Urbana-Champaign. 8 | All rights reserved. 9 | 10 | Developed by: 11 | 12 | LLVM Team 13 | 14 | University of Illinois at Urbana-Champaign 15 | 16 | http://llvm.org 17 | 18 | Permission is hereby granted, free of charge, to any person obtaining a copy of 19 | this software and associated documentation files (the "Software"), to deal with 20 | the Software without restriction, including without limitation the rights to 21 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 22 | of the Software, and to permit persons to whom the Software is furnished to do 23 | so, subject to the following conditions: 24 | 25 | * Redistributions of source code must retain the above copyright notice, 26 | this list of conditions and the following disclaimers. 27 | 28 | * Redistributions in binary form must reproduce the above copyright notice, 29 | this list of conditions and the following disclaimers in the 30 | documentation and/or other materials provided with the distribution. 31 | 32 | * Neither the names of the LLVM Team, University of Illinois at 33 | Urbana-Champaign, nor the names of its contributors may be used to 34 | endorse or promote products derived from this Software without specific 35 | prior written permission. 36 | 37 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 38 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 39 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 40 | CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 41 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 42 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE 43 | SOFTWARE. 44 | 45 | ============================================================================== 46 | Copyrights and Licenses for Third Party Software Distributed with LLVM: 47 | ============================================================================== 48 | The LLVM software contains code written by third parties. Such software will 49 | have its own individual LICENSE.TXT file in the directory in which it appears. 50 | This file will describe the copyrights, license, and restrictions which apply 51 | to that code. 52 | 53 | The disclaimer of warranty in the University of Illinois Open Source License 54 | applies to all code in the LLVM Distribution, and nothing in any of the 55 | other licenses gives permission to use the names of the LLVM Team or the 56 | University of Illinois to endorse or promote products derived from this 57 | Software. 58 | 59 | The following pieces of software have additional or alternate copyrights, 60 | licenses, and/or restrictions: 61 | 62 | Program Directory 63 | ------- --------- 64 | Autoconf llvm/autoconf 65 | llvm/projects/ModuleMaker/autoconf 66 | llvm/projects/sample/autoconf 67 | Google Test llvm/utils/unittest/googletest 68 | OpenBSD regex llvm/lib/Support/{reg*, COPYRIGHT.regex} 69 | pyyaml tests llvm/test/YAMLParser/{*.data, LICENSE.TXT} 70 | ARM contributions llvm/lib/Target/ARM/LICENSE.TXT 71 | md5 contributions llvm/lib/Support/MD5.cpp llvm/include/llvm/Support/MD5.h 72 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/include/windowsce/stdint.h: -------------------------------------------------------------------------------- 1 | 2 | #if defined(_MSC_VER) && defined(_WIN32_WCE) && (_WIN32_WCE < 0x800) && !defined(_STDINT_H_) && !defined(_STDINT) 3 | #define _STDINT 4 | 5 | typedef __int8 6 | int8_t, 7 | int_least8_t; 8 | 9 | typedef __int16 10 | int16_t, 11 | int_least16_t; 12 | 13 | typedef __int32 14 | int32_t, 15 | int_least32_t, 16 | int_fast8_t, 17 | int_fast16_t, 18 | int_fast32_t; 19 | 20 | typedef __int64 21 | int64_t, 22 | intmax_t, 23 | int_least64_t, 24 | int_fast64_t; 25 | 26 | typedef unsigned __int8 27 | uint8_t, 28 | uint_least8_t; 29 | 30 | typedef unsigned __int16 31 | uint16_t, 32 | uint_least16_t; 33 | 34 | typedef unsigned __int32 35 | uint32_t, 36 | uint_least32_t, 37 | uint_fast8_t, 38 | uint_fast16_t, 39 | uint_fast32_t; 40 | 41 | typedef unsigned __int64 42 | uint64_t, 43 | uintmax_t, 44 | uint_least64_t, 45 | uint_fast64_t; 46 | 47 | #ifndef _INTPTR_T_DEFINED 48 | #define _INTPTR_T_DEFINED 49 | typedef __int32 intptr_t; 50 | #endif 51 | 52 | #ifndef _UINTPTR_T_DEFINED 53 | #define _UINTPTR_T_DEFINED 54 | typedef unsigned __int32 uintptr_t; 55 | #endif 56 | 57 | #define INT8_MIN (-127i8 - 1) 58 | #define INT16_MIN (-32767i16 - 1) 59 | #define INT32_MIN (-2147483647i32 - 1) 60 | #define INT64_MIN (-9223372036854775807i64 - 1) 61 | #define INT8_MAX 127i8 62 | #define INT16_MAX 32767i16 63 | #define INT32_MAX 2147483647i32 64 | #define INT64_MAX 9223372036854775807i64 65 | #define UINT8_MAX 0xffui8 66 | #define UINT16_MAX 0xffffui16 67 | #define UINT32_MAX 0xffffffffui32 68 | #define UINT64_MAX 0xffffffffffffffffui64 69 | 70 | #define INT_LEAST8_MIN INT8_MIN 71 | #define INT_LEAST16_MIN INT16_MIN 72 | #define INT_LEAST32_MIN INT32_MIN 73 | #define INT_LEAST64_MIN INT64_MIN 74 | #define INT_LEAST8_MAX INT8_MAX 75 | #define INT_LEAST16_MAX INT16_MAX 76 | #define INT_LEAST32_MAX INT32_MAX 77 | #define INT_LEAST64_MAX INT64_MAX 78 | #define UINT_LEAST8_MAX UINT8_MAX 79 | #define UINT_LEAST16_MAX UINT16_MAX 80 | #define UINT_LEAST32_MAX UINT32_MAX 81 | #define UINT_LEAST64_MAX UINT64_MAX 82 | 83 | #define INT_FAST8_MIN INT8_MIN 84 | #define INT_FAST16_MIN INT32_MIN 85 | #define INT_FAST32_MIN INT32_MIN 86 | #define INT_FAST64_MIN INT64_MIN 87 | #define INT_FAST8_MAX INT8_MAX 88 | #define INT_FAST16_MAX INT32_MAX 89 | #define INT_FAST32_MAX INT32_MAX 90 | #define INT_FAST64_MAX INT64_MAX 91 | #define UINT_FAST8_MAX UINT8_MAX 92 | #define UINT_FAST16_MAX UINT32_MAX 93 | #define UINT_FAST32_MAX UINT32_MAX 94 | #define UINT_FAST64_MAX UINT64_MAX 95 | 96 | #define INTPTR_MIN INT32_MIN 97 | #define INTPTR_MAX INT32_MAX 98 | #define UINTPTR_MAX UINT32_MAX 99 | 100 | #define INTMAX_MIN INT64_MIN 101 | #define INTMAX_MAX INT64_MAX 102 | #define UINTMAX_MAX UINT64_MAX 103 | 104 | #define PTRDIFF_MIN INTPTR_MIN 105 | #define PTRDIFF_MAX INTPTR_MAX 106 | 107 | #ifndef SIZE_MAX 108 | #define SIZE_MAX UINTPTR_MAX 109 | #endif 110 | 111 | #define SIG_ATOMIC_MIN INT32_MIN 112 | #define SIG_ATOMIC_MAX INT32_MAX 113 | 114 | #define WCHAR_MIN 0x0000 115 | #define WCHAR_MAX 0xffff 116 | 117 | #define WINT_MIN 0x0000 118 | #define WINT_MAX 0xffff 119 | 120 | #define INT8_C(x) (x) 121 | #define INT16_C(x) (x) 122 | #define INT32_C(x) (x) 123 | #define INT64_C(x) (x ## LL) 124 | 125 | #define UINT8_C(x) (x) 126 | #define UINT16_C(x) (x) 127 | #define UINT32_C(x) (x ## U) 128 | #define UINT64_C(x) (x ## ULL) 129 | 130 | #define INTMAX_C(x) INT64_C(x) 131 | #define UINTMAX_C(x) UINT64_C(x) 132 | 133 | #endif 134 | -------------------------------------------------------------------------------- /patch_kernel_root/analyze_kernel.cpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "analyze_kernel.h" 3 | 4 | AnalyzeKernel::AnalyzeKernel(const std::vector& file_buf) : m_file_buf(file_buf), m_kernel_sym_parser(file_buf) 5 | { 6 | } 7 | 8 | AnalyzeKernel::~AnalyzeKernel() 9 | { 10 | } 11 | 12 | bool AnalyzeKernel::analyze_kernel_symbol() { 13 | if (!m_kernel_sym_parser.init_kallsyms_lookup_name()) { 14 | std::cout << "Failed to initialize kallsyms lookup name" << std::endl; 15 | return false; 16 | } 17 | if (!find_symbol_offset()) { 18 | std::cout << "Failed to find symbol offset" << std::endl; 19 | return false; 20 | } 21 | return true; 22 | } 23 | 24 | KernelSymbolOffset AnalyzeKernel::get_symbol_offset() { 25 | return m_kernel_sym_offset; 26 | } 27 | 28 | bool AnalyzeKernel::is_kernel_version_less_equal(const std::string& ver) { 29 | return m_kernel_sym_parser.is_kernel_version_less_equal(ver); 30 | } 31 | 32 | bool AnalyzeKernel::find_symbol_offset() { 33 | m_kernel_sym_offset._text_offset = m_kernel_sym_parser.kallsyms_lookup_name("_text"); 34 | m_kernel_sym_offset._stext_offset = m_kernel_sym_parser.kallsyms_lookup_name("_stext"); 35 | m_kernel_sym_offset.panic_offset = m_kernel_sym_parser.kallsyms_lookup_name("panic"); 36 | 37 | m_kernel_sym_offset.__do_execve_file_offset = m_kernel_sym_parser.kallsyms_lookup_name("__do_execve_file"); 38 | 39 | m_kernel_sym_offset.do_execveat_common_offset = m_kernel_sym_parser.kallsyms_lookup_name("do_execveat_common"); 40 | if (m_kernel_sym_offset.do_execveat_common_offset == 0) { 41 | m_kernel_sym_offset.do_execveat_common_offset = m_kernel_sym_parser.kallsyms_lookup_name("do_execveat_common", true); 42 | } 43 | 44 | m_kernel_sym_offset.do_execve_common_offset = m_kernel_sym_parser.kallsyms_lookup_name("do_execve_common"); 45 | if (m_kernel_sym_offset.do_execve_common_offset == 0) { 46 | m_kernel_sym_offset.do_execve_common_offset = m_kernel_sym_parser.kallsyms_lookup_name("do_execve_common", true); 47 | } 48 | 49 | m_kernel_sym_offset.do_execveat_offset = m_kernel_sym_parser.kallsyms_lookup_name("do_execveat"); 50 | m_kernel_sym_offset.do_execve_offset = m_kernel_sym_parser.kallsyms_lookup_name("do_execve"); 51 | 52 | 53 | m_kernel_sym_offset.avc_denied_offset = m_kernel_sym_parser.kallsyms_lookup_name("avc_denied"); 54 | if (m_kernel_sym_offset.avc_denied_offset == 0) { 55 | m_kernel_sym_offset.avc_denied_offset = m_kernel_sym_parser.kallsyms_lookup_name("avc_denied", true); 56 | } 57 | 58 | m_kernel_sym_offset.revert_creds_offset = m_kernel_sym_parser.kallsyms_lookup_name("revert_creds"); 59 | m_kernel_sym_offset.prctl_get_seccomp_offset = m_kernel_sym_parser.kallsyms_lookup_name("prctl_get_seccomp"); // backup: seccomp_filter_release 60 | m_kernel_sym_offset.__cfi_check_offset = m_kernel_sym_parser.kallsyms_lookup_name("__cfi_check"); 61 | m_kernel_sym_offset.__cfi_check_fail_offset = m_kernel_sym_parser.kallsyms_lookup_name("__cfi_check_fail"); 62 | m_kernel_sym_offset.__cfi_slowpath_diag_offset = m_kernel_sym_parser.kallsyms_lookup_name("__cfi_slowpath_diag"); 63 | m_kernel_sym_offset.__cfi_slowpath_offset = m_kernel_sym_parser.kallsyms_lookup_name("__cfi_slowpath"); 64 | m_kernel_sym_offset.__ubsan_handle_cfi_check_fail_abort_offset = m_kernel_sym_parser.kallsyms_lookup_name("__ubsan_handle_cfi_check_fail_abort"); 65 | m_kernel_sym_offset.__ubsan_handle_cfi_check_fail_offset = m_kernel_sym_parser.kallsyms_lookup_name("__ubsan_handle_cfi_check_fail"); 66 | m_kernel_sym_offset.report_cfi_failure_offset = m_kernel_sym_parser.kallsyms_lookup_name("report_cfi_failure"); 67 | return (m_kernel_sym_offset.do_execve_offset || m_kernel_sym_offset.do_execveat_offset || m_kernel_sym_offset.do_execveat_common_offset 68 | ) && m_kernel_sym_offset.avc_denied_offset && m_kernel_sym_offset.revert_creds_offset && m_kernel_sym_offset.prctl_get_seccomp_offset; 69 | } -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/include/platform.h: -------------------------------------------------------------------------------- 1 | /* Capstone Disassembly Engine */ 2 | /* By Axel Souchet & Nguyen Anh Quynh, 2014 */ 3 | 4 | #ifndef CAPSTONE_PLATFORM_H 5 | #define CAPSTONE_PLATFORM_H 6 | 7 | // handle C99 issue (for pre-2013 VisualStudio) 8 | #if !defined(__CYGWIN__) && !defined(__MINGW32__) && !defined(__MINGW64__) && (defined (WIN32) || defined (WIN64) || defined (_WIN32) || defined (_WIN64)) 9 | // MSVC 10 | 11 | // stdbool.h 12 | #if (_MSC_VER < 1800) || defined(_KERNEL_MODE) 13 | // this system does not have stdbool.h 14 | #ifndef __cplusplus 15 | typedef unsigned char bool; 16 | #define false 0 17 | #define true 1 18 | #endif 19 | 20 | #else 21 | // VisualStudio 2013+ -> C99 is supported 22 | #include 23 | #endif 24 | 25 | #else 26 | // not MSVC -> C99 is supported 27 | #include 28 | #endif 29 | 30 | 31 | // handle C99 issue (for pre-2013 VisualStudio) 32 | #if defined(CAPSTONE_HAS_OSXKERNEL) || (defined(_MSC_VER) && (_MSC_VER <= 1700 || defined(_KERNEL_MODE))) 33 | // this system does not have inttypes.h 34 | 35 | #if defined(_MSC_VER) && (_MSC_VER < 1600 || defined(_KERNEL_MODE)) 36 | // this system does not have stdint.h 37 | typedef signed char int8_t; 38 | typedef signed short int16_t; 39 | typedef signed int int32_t; 40 | typedef unsigned char uint8_t; 41 | typedef unsigned short uint16_t; 42 | typedef unsigned int uint32_t; 43 | typedef signed long long int64_t; 44 | typedef unsigned long long uint64_t; 45 | 46 | #define INT8_MIN (-127i8 - 1) 47 | #define INT16_MIN (-32767i16 - 1) 48 | #define INT32_MIN (-2147483647i32 - 1) 49 | #define INT64_MIN (-9223372036854775807i64 - 1) 50 | #define INT8_MAX 127i8 51 | #define INT16_MAX 32767i16 52 | #define INT32_MAX 2147483647i32 53 | #define INT64_MAX 9223372036854775807i64 54 | #define UINT8_MAX 0xffui8 55 | #define UINT16_MAX 0xffffui16 56 | #define UINT32_MAX 0xffffffffui32 57 | #define UINT64_MAX 0xffffffffffffffffui64 58 | #endif 59 | 60 | #define __PRI_8_LENGTH_MODIFIER__ "hh" 61 | #define __PRI_64_LENGTH_MODIFIER__ "ll" 62 | 63 | #define PRId8 __PRI_8_LENGTH_MODIFIER__ "d" 64 | #define PRIi8 __PRI_8_LENGTH_MODIFIER__ "i" 65 | #define PRIo8 __PRI_8_LENGTH_MODIFIER__ "o" 66 | #define PRIu8 __PRI_8_LENGTH_MODIFIER__ "u" 67 | #define PRIx8 __PRI_8_LENGTH_MODIFIER__ "x" 68 | #define PRIX8 __PRI_8_LENGTH_MODIFIER__ "X" 69 | 70 | #define PRId16 "hd" 71 | #define PRIi16 "hi" 72 | #define PRIo16 "ho" 73 | #define PRIu16 "hu" 74 | #define PRIx16 "hx" 75 | #define PRIX16 "hX" 76 | 77 | #if defined(_MSC_VER) && _MSC_VER <= 1700 78 | #define PRId32 "ld" 79 | #define PRIi32 "li" 80 | #define PRIo32 "lo" 81 | #define PRIu32 "lu" 82 | #define PRIx32 "lx" 83 | #define PRIX32 "lX" 84 | #else // OSX 85 | #define PRId32 "d" 86 | #define PRIi32 "i" 87 | #define PRIo32 "o" 88 | #define PRIu32 "u" 89 | #define PRIx32 "x" 90 | #define PRIX32 "X" 91 | #endif 92 | 93 | #if defined(_MSC_VER) && _MSC_VER <= 1700 94 | // redefine functions from inttypes.h used in cstool 95 | #define strtoull _strtoui64 96 | #endif 97 | 98 | #define PRId64 __PRI_64_LENGTH_MODIFIER__ "d" 99 | #define PRIi64 __PRI_64_LENGTH_MODIFIER__ "i" 100 | #define PRIo64 __PRI_64_LENGTH_MODIFIER__ "o" 101 | #define PRIu64 __PRI_64_LENGTH_MODIFIER__ "u" 102 | #define PRIx64 __PRI_64_LENGTH_MODIFIER__ "x" 103 | #define PRIX64 __PRI_64_LENGTH_MODIFIER__ "X" 104 | 105 | #else 106 | // this system has inttypes.h by default 107 | #include 108 | #endif 109 | 110 | #endif 111 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/include/capstone/platform.h: -------------------------------------------------------------------------------- 1 | /* Capstone Disassembly Engine */ 2 | /* By Axel Souchet & Nguyen Anh Quynh, 2014 */ 3 | 4 | #ifndef CAPSTONE_PLATFORM_H 5 | #define CAPSTONE_PLATFORM_H 6 | 7 | 8 | // handle C99 issue (for pre-2013 VisualStudio) 9 | #if !defined(__CYGWIN__) && !defined(__MINGW32__) && !defined(__MINGW64__) && (defined (WIN32) || defined (WIN64) || defined (_WIN32) || defined (_WIN64)) 10 | // MSVC 11 | 12 | // stdbool.h 13 | #if (_MSC_VER < 1800) || defined(_KERNEL_MODE) 14 | // this system does not have stdbool.h 15 | #ifndef __cplusplus 16 | typedef unsigned char bool; 17 | #define false 0 18 | #define true 1 19 | #endif // __cplusplus 20 | 21 | #else 22 | // VisualStudio 2013+ -> C99 is supported 23 | #include 24 | #endif // (_MSC_VER < 1800) || defined(_KERNEL_MODE) 25 | 26 | #else 27 | // not MSVC -> C99 is supported 28 | #include 29 | #endif // !defined(__CYGWIN__) && !defined(__MINGW32__) && !defined(__MINGW64__) && (defined (WIN32) || defined (WIN64) || defined (_WIN32) || defined (_WIN64)) 30 | 31 | 32 | // handle inttypes.h / stdint.h compatibility 33 | #if defined(_WIN32_WCE) && (_WIN32_WCE < 0x800) 34 | #include "windowsce/stdint.h" 35 | #endif // defined(_WIN32_WCE) && (_WIN32_WCE < 0x800) 36 | 37 | #if defined(CAPSTONE_HAS_OSXKERNEL) || (defined(_MSC_VER) && (_MSC_VER <= 1700 || defined(_KERNEL_MODE))) 38 | // this system does not have inttypes.h 39 | 40 | #if defined(_MSC_VER) && (_MSC_VER <= 1600 || defined(_KERNEL_MODE)) 41 | // this system does not have stdint.h 42 | typedef signed char int8_t; 43 | typedef signed short int16_t; 44 | typedef signed int int32_t; 45 | typedef unsigned char uint8_t; 46 | typedef unsigned short uint16_t; 47 | typedef unsigned int uint32_t; 48 | typedef signed long long int64_t; 49 | typedef unsigned long long uint64_t; 50 | #endif // defined(_MSC_VER) && (_MSC_VER <= 1600 || defined(_KERNEL_MODE)) 51 | 52 | #if defined(_MSC_VER) && (_MSC_VER < 1600 || defined(_KERNEL_MODE)) 53 | #define INT8_MIN (-127i8 - 1) 54 | #define INT16_MIN (-32767i16 - 1) 55 | #define INT32_MIN (-2147483647i32 - 1) 56 | #define INT64_MIN (-9223372036854775807i64 - 1) 57 | #define INT8_MAX 127i8 58 | #define INT16_MAX 32767i16 59 | #define INT32_MAX 2147483647i32 60 | #define INT64_MAX 9223372036854775807i64 61 | #define UINT8_MAX 0xffui8 62 | #define UINT16_MAX 0xffffui16 63 | #define UINT32_MAX 0xffffffffui32 64 | #define UINT64_MAX 0xffffffffffffffffui64 65 | #endif // defined(_MSC_VER) && (_MSC_VER < 1600 || defined(_KERNEL_MODE)) 66 | 67 | #ifdef CAPSTONE_HAS_OSXKERNEL 68 | // this system has stdint.h 69 | #include 70 | #endif 71 | 72 | #define __PRI_8_LENGTH_MODIFIER__ "hh" 73 | #define __PRI_64_LENGTH_MODIFIER__ "ll" 74 | 75 | #define PRId8 __PRI_8_LENGTH_MODIFIER__ "d" 76 | #define PRIi8 __PRI_8_LENGTH_MODIFIER__ "i" 77 | #define PRIo8 __PRI_8_LENGTH_MODIFIER__ "o" 78 | #define PRIu8 __PRI_8_LENGTH_MODIFIER__ "u" 79 | #define PRIx8 __PRI_8_LENGTH_MODIFIER__ "x" 80 | #define PRIX8 __PRI_8_LENGTH_MODIFIER__ "X" 81 | 82 | #define PRId16 "hd" 83 | #define PRIi16 "hi" 84 | #define PRIo16 "ho" 85 | #define PRIu16 "hu" 86 | #define PRIx16 "hx" 87 | #define PRIX16 "hX" 88 | 89 | #if defined(_MSC_VER) && _MSC_VER <= 1700 90 | #define PRId32 "ld" 91 | #define PRIi32 "li" 92 | #define PRIo32 "lo" 93 | #define PRIu32 "lu" 94 | #define PRIx32 "lx" 95 | #define PRIX32 "lX" 96 | #else // OSX 97 | #define PRId32 "d" 98 | #define PRIi32 "i" 99 | #define PRIo32 "o" 100 | #define PRIu32 "u" 101 | #define PRIx32 "x" 102 | #define PRIX32 "X" 103 | #endif // defined(_MSC_VER) && _MSC_VER <= 1700 104 | 105 | #if defined(_MSC_VER) && _MSC_VER <= 1700 106 | // redefine functions from inttypes.h used in cstool 107 | #define strtoull _strtoui64 108 | #endif 109 | 110 | #define PRId64 __PRI_64_LENGTH_MODIFIER__ "d" 111 | #define PRIi64 __PRI_64_LENGTH_MODIFIER__ "i" 112 | #define PRIo64 __PRI_64_LENGTH_MODIFIER__ "o" 113 | #define PRIu64 __PRI_64_LENGTH_MODIFIER__ "u" 114 | #define PRIx64 __PRI_64_LENGTH_MODIFIER__ "x" 115 | #define PRIX64 __PRI_64_LENGTH_MODIFIER__ "X" 116 | 117 | #else 118 | // this system has inttypes.h by default 119 | #include 120 | #endif // defined(CAPSTONE_HAS_OSXKERNEL) || (defined(_MSC_VER) && (_MSC_VER <= 1700 || defined(_KERNEL_MODE))) 121 | 122 | #endif 123 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/include/capstone/evm.h: -------------------------------------------------------------------------------- 1 | #ifndef CAPSTONE_EVM_H 2 | #define CAPSTONE_EVM_H 3 | 4 | /* Capstone Disassembly Engine */ 5 | /* By Nguyen Anh Quynh , 2013-2018 */ 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | #include "platform.h" 12 | 13 | #ifdef _MSC_VER 14 | #pragma warning(disable:4201) 15 | #endif 16 | 17 | /// Instruction structure 18 | typedef struct cs_evm { 19 | unsigned char pop; ///< number of items popped from the stack 20 | unsigned char push; ///< number of items pushed into the stack 21 | unsigned int fee; ///< gas fee for the instruction 22 | } cs_evm; 23 | 24 | /// EVM instruction 25 | typedef enum evm_insn { 26 | EVM_INS_STOP = 0, 27 | EVM_INS_ADD = 1, 28 | EVM_INS_MUL = 2, 29 | EVM_INS_SUB = 3, 30 | EVM_INS_DIV = 4, 31 | EVM_INS_SDIV = 5, 32 | EVM_INS_MOD = 6, 33 | EVM_INS_SMOD = 7, 34 | EVM_INS_ADDMOD = 8, 35 | EVM_INS_MULMOD = 9, 36 | EVM_INS_EXP = 10, 37 | EVM_INS_SIGNEXTEND = 11, 38 | EVM_INS_LT = 16, 39 | EVM_INS_GT = 17, 40 | EVM_INS_SLT = 18, 41 | EVM_INS_SGT = 19, 42 | EVM_INS_EQ = 20, 43 | EVM_INS_ISZERO = 21, 44 | EVM_INS_AND = 22, 45 | EVM_INS_OR = 23, 46 | EVM_INS_XOR = 24, 47 | EVM_INS_NOT = 25, 48 | EVM_INS_BYTE = 26, 49 | EVM_INS_SHA3 = 32, 50 | EVM_INS_ADDRESS = 48, 51 | EVM_INS_BALANCE = 49, 52 | EVM_INS_ORIGIN = 50, 53 | EVM_INS_CALLER = 51, 54 | EVM_INS_CALLVALUE = 52, 55 | EVM_INS_CALLDATALOAD = 53, 56 | EVM_INS_CALLDATASIZE = 54, 57 | EVM_INS_CALLDATACOPY = 55, 58 | EVM_INS_CODESIZE = 56, 59 | EVM_INS_CODECOPY = 57, 60 | EVM_INS_GASPRICE = 58, 61 | EVM_INS_EXTCODESIZE = 59, 62 | EVM_INS_EXTCODECOPY = 60, 63 | EVM_INS_RETURNDATASIZE = 61, 64 | EVM_INS_RETURNDATACOPY = 62, 65 | EVM_INS_BLOCKHASH = 64, 66 | EVM_INS_COINBASE = 65, 67 | EVM_INS_TIMESTAMP = 66, 68 | EVM_INS_NUMBER = 67, 69 | EVM_INS_DIFFICULTY = 68, 70 | EVM_INS_GASLIMIT = 69, 71 | EVM_INS_POP = 80, 72 | EVM_INS_MLOAD = 81, 73 | EVM_INS_MSTORE = 82, 74 | EVM_INS_MSTORE8 = 83, 75 | EVM_INS_SLOAD = 84, 76 | EVM_INS_SSTORE = 85, 77 | EVM_INS_JUMP = 86, 78 | EVM_INS_JUMPI = 87, 79 | EVM_INS_PC = 88, 80 | EVM_INS_MSIZE = 89, 81 | EVM_INS_GAS = 90, 82 | EVM_INS_JUMPDEST = 91, 83 | EVM_INS_PUSH1 = 96, 84 | EVM_INS_PUSH2 = 97, 85 | EVM_INS_PUSH3 = 98, 86 | EVM_INS_PUSH4 = 99, 87 | EVM_INS_PUSH5 = 100, 88 | EVM_INS_PUSH6 = 101, 89 | EVM_INS_PUSH7 = 102, 90 | EVM_INS_PUSH8 = 103, 91 | EVM_INS_PUSH9 = 104, 92 | EVM_INS_PUSH10 = 105, 93 | EVM_INS_PUSH11 = 106, 94 | EVM_INS_PUSH12 = 107, 95 | EVM_INS_PUSH13 = 108, 96 | EVM_INS_PUSH14 = 109, 97 | EVM_INS_PUSH15 = 110, 98 | EVM_INS_PUSH16 = 111, 99 | EVM_INS_PUSH17 = 112, 100 | EVM_INS_PUSH18 = 113, 101 | EVM_INS_PUSH19 = 114, 102 | EVM_INS_PUSH20 = 115, 103 | EVM_INS_PUSH21 = 116, 104 | EVM_INS_PUSH22 = 117, 105 | EVM_INS_PUSH23 = 118, 106 | EVM_INS_PUSH24 = 119, 107 | EVM_INS_PUSH25 = 120, 108 | EVM_INS_PUSH26 = 121, 109 | EVM_INS_PUSH27 = 122, 110 | EVM_INS_PUSH28 = 123, 111 | EVM_INS_PUSH29 = 124, 112 | EVM_INS_PUSH30 = 125, 113 | EVM_INS_PUSH31 = 126, 114 | EVM_INS_PUSH32 = 127, 115 | EVM_INS_DUP1 = 128, 116 | EVM_INS_DUP2 = 129, 117 | EVM_INS_DUP3 = 130, 118 | EVM_INS_DUP4 = 131, 119 | EVM_INS_DUP5 = 132, 120 | EVM_INS_DUP6 = 133, 121 | EVM_INS_DUP7 = 134, 122 | EVM_INS_DUP8 = 135, 123 | EVM_INS_DUP9 = 136, 124 | EVM_INS_DUP10 = 137, 125 | EVM_INS_DUP11 = 138, 126 | EVM_INS_DUP12 = 139, 127 | EVM_INS_DUP13 = 140, 128 | EVM_INS_DUP14 = 141, 129 | EVM_INS_DUP15 = 142, 130 | EVM_INS_DUP16 = 143, 131 | EVM_INS_SWAP1 = 144, 132 | EVM_INS_SWAP2 = 145, 133 | EVM_INS_SWAP3 = 146, 134 | EVM_INS_SWAP4 = 147, 135 | EVM_INS_SWAP5 = 148, 136 | EVM_INS_SWAP6 = 149, 137 | EVM_INS_SWAP7 = 150, 138 | EVM_INS_SWAP8 = 151, 139 | EVM_INS_SWAP9 = 152, 140 | EVM_INS_SWAP10 = 153, 141 | EVM_INS_SWAP11 = 154, 142 | EVM_INS_SWAP12 = 155, 143 | EVM_INS_SWAP13 = 156, 144 | EVM_INS_SWAP14 = 157, 145 | EVM_INS_SWAP15 = 158, 146 | EVM_INS_SWAP16 = 159, 147 | EVM_INS_LOG0 = 160, 148 | EVM_INS_LOG1 = 161, 149 | EVM_INS_LOG2 = 162, 150 | EVM_INS_LOG3 = 163, 151 | EVM_INS_LOG4 = 164, 152 | EVM_INS_CREATE = 240, 153 | EVM_INS_CALL = 241, 154 | EVM_INS_CALLCODE = 242, 155 | EVM_INS_RETURN = 243, 156 | EVM_INS_DELEGATECALL = 244, 157 | EVM_INS_CALLBLACKBOX = 245, 158 | EVM_INS_STATICCALL = 250, 159 | EVM_INS_REVERT = 253, 160 | EVM_INS_SUICIDE = 255, 161 | 162 | EVM_INS_INVALID = 512, 163 | EVM_INS_ENDING, // <-- mark the end of the list of instructions 164 | } evm_insn; 165 | 166 | /// Group of EVM instructions 167 | typedef enum evm_insn_group { 168 | EVM_GRP_INVALID = 0, ///< = CS_GRP_INVALID 169 | 170 | EVM_GRP_JUMP, ///< all jump instructions 171 | 172 | EVM_GRP_MATH = 8, ///< math instructions 173 | EVM_GRP_STACK_WRITE, ///< instructions write to stack 174 | EVM_GRP_STACK_READ, ///< instructions read from stack 175 | EVM_GRP_MEM_WRITE, ///< instructions write to memory 176 | EVM_GRP_MEM_READ, ///< instructions read from memory 177 | EVM_GRP_STORE_WRITE, ///< instructions write to storage 178 | EVM_GRP_STORE_READ, ///< instructions read from storage 179 | EVM_GRP_HALT, ///< instructions halt execution 180 | 181 | EVM_GRP_ENDING, ///< <-- mark the end of the list of groups 182 | } evm_insn_group; 183 | 184 | #ifdef __cplusplus 185 | } 186 | #endif 187 | 188 | #endif 189 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/include/capstone/xcore.h: -------------------------------------------------------------------------------- 1 | #ifndef CAPSTONE_XCORE_H 2 | #define CAPSTONE_XCORE_H 3 | 4 | /* Capstone Disassembly Engine */ 5 | /* By Nguyen Anh Quynh , 2014-2015 */ 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | #include "platform.h" 12 | 13 | #ifdef _MSC_VER 14 | #pragma warning(disable:4201) 15 | #endif 16 | 17 | /// Operand type for instruction's operands 18 | typedef enum xcore_op_type { 19 | XCORE_OP_INVALID = 0, ///< = CS_OP_INVALID (Uninitialized). 20 | XCORE_OP_REG, ///< = CS_OP_REG (Register operand). 21 | XCORE_OP_IMM, ///< = CS_OP_IMM (Immediate operand). 22 | XCORE_OP_MEM, ///< = CS_OP_MEM (Memory operand). 23 | } xcore_op_type; 24 | 25 | /// XCore registers 26 | typedef enum xcore_reg { 27 | XCORE_REG_INVALID = 0, 28 | 29 | XCORE_REG_CP, 30 | XCORE_REG_DP, 31 | XCORE_REG_LR, 32 | XCORE_REG_SP, 33 | XCORE_REG_R0, 34 | XCORE_REG_R1, 35 | XCORE_REG_R2, 36 | XCORE_REG_R3, 37 | XCORE_REG_R4, 38 | XCORE_REG_R5, 39 | XCORE_REG_R6, 40 | XCORE_REG_R7, 41 | XCORE_REG_R8, 42 | XCORE_REG_R9, 43 | XCORE_REG_R10, 44 | XCORE_REG_R11, 45 | 46 | // pseudo registers 47 | XCORE_REG_PC, ///< pc 48 | 49 | // internal thread registers 50 | // see The-XMOS-XS1-Architecture(X7879A).pdf 51 | XCORE_REG_SCP, ///< save pc 52 | XCORE_REG_SSR, //< save status 53 | XCORE_REG_ET, //< exception type 54 | XCORE_REG_ED, //< exception data 55 | XCORE_REG_SED, //< save exception data 56 | XCORE_REG_KEP, //< kernel entry pointer 57 | XCORE_REG_KSP, //< kernel stack pointer 58 | XCORE_REG_ID, //< thread ID 59 | 60 | XCORE_REG_ENDING, // <-- mark the end of the list of registers 61 | } xcore_reg; 62 | 63 | /// Instruction's operand referring to memory 64 | /// This is associated with XCORE_OP_MEM operand type above 65 | typedef struct xcore_op_mem { 66 | uint8_t base; ///< base register, can be safely interpreted as 67 | ///< a value of type `xcore_reg`, but it is only 68 | ///< one byte wide 69 | uint8_t index; ///< index register, same conditions apply here 70 | int32_t disp; ///< displacement/offset value 71 | int direct; ///< +1: forward, -1: backward 72 | } xcore_op_mem; 73 | 74 | /// Instruction operand 75 | typedef struct cs_xcore_op { 76 | xcore_op_type type; ///< operand type 77 | union { 78 | xcore_reg reg; ///< register value for REG operand 79 | int32_t imm; ///< immediate value for IMM operand 80 | xcore_op_mem mem; ///< base/disp value for MEM operand 81 | }; 82 | } cs_xcore_op; 83 | 84 | /// Instruction structure 85 | typedef struct cs_xcore { 86 | /// Number of operands of this instruction, 87 | /// or 0 when instruction has no operand. 88 | uint8_t op_count; 89 | cs_xcore_op operands[8]; ///< operands for this instruction. 90 | } cs_xcore; 91 | 92 | /// XCore instruction 93 | typedef enum xcore_insn { 94 | XCORE_INS_INVALID = 0, 95 | 96 | XCORE_INS_ADD, 97 | XCORE_INS_ANDNOT, 98 | XCORE_INS_AND, 99 | XCORE_INS_ASHR, 100 | XCORE_INS_BAU, 101 | XCORE_INS_BITREV, 102 | XCORE_INS_BLA, 103 | XCORE_INS_BLAT, 104 | XCORE_INS_BL, 105 | XCORE_INS_BF, 106 | XCORE_INS_BT, 107 | XCORE_INS_BU, 108 | XCORE_INS_BRU, 109 | XCORE_INS_BYTEREV, 110 | XCORE_INS_CHKCT, 111 | XCORE_INS_CLRE, 112 | XCORE_INS_CLRPT, 113 | XCORE_INS_CLRSR, 114 | XCORE_INS_CLZ, 115 | XCORE_INS_CRC8, 116 | XCORE_INS_CRC32, 117 | XCORE_INS_DCALL, 118 | XCORE_INS_DENTSP, 119 | XCORE_INS_DGETREG, 120 | XCORE_INS_DIVS, 121 | XCORE_INS_DIVU, 122 | XCORE_INS_DRESTSP, 123 | XCORE_INS_DRET, 124 | XCORE_INS_ECALLF, 125 | XCORE_INS_ECALLT, 126 | XCORE_INS_EDU, 127 | XCORE_INS_EEF, 128 | XCORE_INS_EET, 129 | XCORE_INS_EEU, 130 | XCORE_INS_ENDIN, 131 | XCORE_INS_ENTSP, 132 | XCORE_INS_EQ, 133 | XCORE_INS_EXTDP, 134 | XCORE_INS_EXTSP, 135 | XCORE_INS_FREER, 136 | XCORE_INS_FREET, 137 | XCORE_INS_GETD, 138 | XCORE_INS_GET, 139 | XCORE_INS_GETN, 140 | XCORE_INS_GETR, 141 | XCORE_INS_GETSR, 142 | XCORE_INS_GETST, 143 | XCORE_INS_GETTS, 144 | XCORE_INS_INCT, 145 | XCORE_INS_INIT, 146 | XCORE_INS_INPW, 147 | XCORE_INS_INSHR, 148 | XCORE_INS_INT, 149 | XCORE_INS_IN, 150 | XCORE_INS_KCALL, 151 | XCORE_INS_KENTSP, 152 | XCORE_INS_KRESTSP, 153 | XCORE_INS_KRET, 154 | XCORE_INS_LADD, 155 | XCORE_INS_LD16S, 156 | XCORE_INS_LD8U, 157 | XCORE_INS_LDA16, 158 | XCORE_INS_LDAP, 159 | XCORE_INS_LDAW, 160 | XCORE_INS_LDC, 161 | XCORE_INS_LDW, 162 | XCORE_INS_LDIVU, 163 | XCORE_INS_LMUL, 164 | XCORE_INS_LSS, 165 | XCORE_INS_LSUB, 166 | XCORE_INS_LSU, 167 | XCORE_INS_MACCS, 168 | XCORE_INS_MACCU, 169 | XCORE_INS_MJOIN, 170 | XCORE_INS_MKMSK, 171 | XCORE_INS_MSYNC, 172 | XCORE_INS_MUL, 173 | XCORE_INS_NEG, 174 | XCORE_INS_NOT, 175 | XCORE_INS_OR, 176 | XCORE_INS_OUTCT, 177 | XCORE_INS_OUTPW, 178 | XCORE_INS_OUTSHR, 179 | XCORE_INS_OUTT, 180 | XCORE_INS_OUT, 181 | XCORE_INS_PEEK, 182 | XCORE_INS_REMS, 183 | XCORE_INS_REMU, 184 | XCORE_INS_RETSP, 185 | XCORE_INS_SETCLK, 186 | XCORE_INS_SET, 187 | XCORE_INS_SETC, 188 | XCORE_INS_SETD, 189 | XCORE_INS_SETEV, 190 | XCORE_INS_SETN, 191 | XCORE_INS_SETPSC, 192 | XCORE_INS_SETPT, 193 | XCORE_INS_SETRDY, 194 | XCORE_INS_SETSR, 195 | XCORE_INS_SETTW, 196 | XCORE_INS_SETV, 197 | XCORE_INS_SEXT, 198 | XCORE_INS_SHL, 199 | XCORE_INS_SHR, 200 | XCORE_INS_SSYNC, 201 | XCORE_INS_ST16, 202 | XCORE_INS_ST8, 203 | XCORE_INS_STW, 204 | XCORE_INS_SUB, 205 | XCORE_INS_SYNCR, 206 | XCORE_INS_TESTCT, 207 | XCORE_INS_TESTLCL, 208 | XCORE_INS_TESTWCT, 209 | XCORE_INS_TSETMR, 210 | XCORE_INS_START, 211 | XCORE_INS_WAITEF, 212 | XCORE_INS_WAITET, 213 | XCORE_INS_WAITEU, 214 | XCORE_INS_XOR, 215 | XCORE_INS_ZEXT, 216 | 217 | XCORE_INS_ENDING, // <-- mark the end of the list of instructions 218 | } xcore_insn; 219 | 220 | /// Group of XCore instructions 221 | typedef enum xcore_insn_group { 222 | XCORE_GRP_INVALID = 0, ///< = CS_GRP_INVALID 223 | 224 | // Generic groups 225 | // all jump instructions (conditional+direct+indirect jumps) 226 | XCORE_GRP_JUMP, ///< = CS_GRP_JUMP 227 | 228 | XCORE_GRP_ENDING, // <-- mark the end of the list of groups 229 | } xcore_insn_group; 230 | 231 | #ifdef __cplusplus 232 | } 233 | #endif 234 | 235 | #endif 236 | -------------------------------------------------------------------------------- /app/src/main/res/drawable/ic_launcher_background.xml: -------------------------------------------------------------------------------- 1 | 2 | 7 | 10 | 15 | 20 | 25 | 30 | 35 | 40 | 45 | 50 | 55 | 60 | 65 | 70 | 75 | 80 | 85 | 90 | 95 | 100 | 105 | 110 | 115 | 120 | 125 | 130 | 135 | 140 | 145 | 150 | 155 | 160 | 165 | 170 | 171 | -------------------------------------------------------------------------------- /app/src/main/res/res/drawable/ic_launcher_background.xml: -------------------------------------------------------------------------------- 1 | 2 | 7 | 10 | 15 | 20 | 25 | 30 | 35 | 40 | 45 | 50 | 55 | 60 | 65 | 70 | 75 | 80 | 85 | 90 | 95 | 100 | 105 | 110 | 115 | 120 | 125 | 130 | 135 | 140 | 145 | 150 | 155 | 160 | 165 | 170 | 171 | -------------------------------------------------------------------------------- /gradlew: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env sh 2 | 3 | # 4 | # Copyright 2015 the original author or authors. 5 | # 6 | # Licensed under the Apache License, Version 2.0 (the "License"); 7 | # you may not use this file except in compliance with the License. 8 | # You may obtain a copy of the License at 9 | # 10 | # https://www.apache.org/licenses/LICENSE-2.0 11 | # 12 | # Unless required by applicable law or agreed to in writing, software 13 | # distributed under the License is distributed on an "AS IS" BASIS, 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 | # See the License for the specific language governing permissions and 16 | # limitations under the License. 17 | # 18 | 19 | ############################################################################## 20 | ## 21 | ## Gradle start up script for UN*X 22 | ## 23 | ############################################################################## 24 | 25 | # Attempt to set APP_HOME 26 | # Resolve links: $0 may be a link 27 | PRG="$0" 28 | # Need this for relative symlinks. 29 | while [ -h "$PRG" ] ; do 30 | ls=`ls -ld "$PRG"` 31 | link=`expr "$ls" : '.*-> \(.*\)$'` 32 | if expr "$link" : '/.*' > /dev/null; then 33 | PRG="$link" 34 | else 35 | PRG=`dirname "$PRG"`"/$link" 36 | fi 37 | done 38 | SAVED="`pwd`" 39 | cd "`dirname \"$PRG\"`/" >/dev/null 40 | APP_HOME="`pwd -P`" 41 | cd "$SAVED" >/dev/null 42 | 43 | APP_NAME="Gradle" 44 | APP_BASE_NAME=`basename "$0"` 45 | 46 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 47 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' 48 | 49 | # Use the maximum available, or set MAX_FD != -1 to use that value. 50 | MAX_FD="maximum" 51 | 52 | warn () { 53 | echo "$*" 54 | } 55 | 56 | die () { 57 | echo 58 | echo "$*" 59 | echo 60 | exit 1 61 | } 62 | 63 | # OS specific support (must be 'true' or 'false'). 64 | cygwin=false 65 | msys=false 66 | darwin=false 67 | nonstop=false 68 | case "`uname`" in 69 | CYGWIN* ) 70 | cygwin=true 71 | ;; 72 | Darwin* ) 73 | darwin=true 74 | ;; 75 | MINGW* ) 76 | msys=true 77 | ;; 78 | NONSTOP* ) 79 | nonstop=true 80 | ;; 81 | esac 82 | 83 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar 84 | 85 | 86 | # Determine the Java command to use to start the JVM. 87 | if [ -n "$JAVA_HOME" ] ; then 88 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then 89 | # IBM's JDK on AIX uses strange locations for the executables 90 | JAVACMD="$JAVA_HOME/jre/sh/java" 91 | else 92 | JAVACMD="$JAVA_HOME/bin/java" 93 | fi 94 | if [ ! -x "$JAVACMD" ] ; then 95 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME 96 | 97 | Please set the JAVA_HOME variable in your environment to match the 98 | location of your Java installation." 99 | fi 100 | else 101 | JAVACMD="java" 102 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 103 | 104 | Please set the JAVA_HOME variable in your environment to match the 105 | location of your Java installation." 106 | fi 107 | 108 | # Increase the maximum file descriptors if we can. 109 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then 110 | MAX_FD_LIMIT=`ulimit -H -n` 111 | if [ $? -eq 0 ] ; then 112 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then 113 | MAX_FD="$MAX_FD_LIMIT" 114 | fi 115 | ulimit -n $MAX_FD 116 | if [ $? -ne 0 ] ; then 117 | warn "Could not set maximum file descriptor limit: $MAX_FD" 118 | fi 119 | else 120 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" 121 | fi 122 | fi 123 | 124 | # For Darwin, add options to specify how the application appears in the dock 125 | if $darwin; then 126 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" 127 | fi 128 | 129 | # For Cygwin or MSYS, switch paths to Windows format before running java 130 | if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then 131 | APP_HOME=`cygpath --path --mixed "$APP_HOME"` 132 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` 133 | 134 | JAVACMD=`cygpath --unix "$JAVACMD"` 135 | 136 | # We build the pattern for arguments to be converted via cygpath 137 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` 138 | SEP="" 139 | for dir in $ROOTDIRSRAW ; do 140 | ROOTDIRS="$ROOTDIRS$SEP$dir" 141 | SEP="|" 142 | done 143 | OURCYGPATTERN="(^($ROOTDIRS))" 144 | # Add a user-defined pattern to the cygpath arguments 145 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then 146 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" 147 | fi 148 | # Now convert the arguments - kludge to limit ourselves to /bin/sh 149 | i=0 150 | for arg in "$@" ; do 151 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` 152 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option 153 | 154 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition 155 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` 156 | else 157 | eval `echo args$i`="\"$arg\"" 158 | fi 159 | i=`expr $i + 1` 160 | done 161 | case $i in 162 | 0) set -- ;; 163 | 1) set -- "$args0" ;; 164 | 2) set -- "$args0" "$args1" ;; 165 | 3) set -- "$args0" "$args1" "$args2" ;; 166 | 4) set -- "$args0" "$args1" "$args2" "$args3" ;; 167 | 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; 168 | 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; 169 | 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; 170 | 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; 171 | 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; 172 | esac 173 | fi 174 | 175 | # Escape application args 176 | save () { 177 | for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done 178 | echo " " 179 | } 180 | APP_ARGS=`save "$@"` 181 | 182 | # Collect all arguments for the java command, following the shell quoting and substitution rules 183 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" 184 | 185 | exec "$JAVACMD" "$@" 186 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/find_mrs_register.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include "capstone-4.0.2-win64/include/capstone/capstone.h" 8 | 9 | struct code_line { 10 | uint64_t addr; 11 | std::string mnemonic; 12 | std::string op_str; 13 | }; 14 | 15 | 16 | bool handle_mrs(const std::vector& v_code_line, std::vector& v_register_offset) { 17 | bool res = false; 18 | for (auto x = 0; x < v_code_line.size(); x++) { 19 | auto& item = v_code_line[x]; 20 | if (item.mnemonic != "mrs") { 21 | continue; 22 | } 23 | int xCurrentReg = 0; 24 | if (sscanf(item.op_str.c_str(), "x%d sp_el0", &xCurrentReg) != 1) { 25 | continue; 26 | } 27 | auto y = x + 1; 28 | if (y >= v_code_line.size()) { 29 | break; 30 | } 31 | 32 | size_t xFirstRegNum = 0; 33 | size_t xFirstRegOffset = 0; 34 | 35 | for (; y < v_code_line.size(); y++) { 36 | xFirstRegNum = 0; 37 | xFirstRegOffset = 0; 38 | auto& item2 = v_code_line[y]; 39 | if (item2.mnemonic.length() >= 3 && item2.mnemonic.substr(0, 3) == "ldr") { 40 | std::stringstream fmt; 41 | fmt << "x%d, [x" << xCurrentReg << ", #%llx]"; 42 | if (sscanf(item2.op_str.c_str(), fmt.str().c_str(), &xFirstRegNum, &xFirstRegOffset) != 2) { 43 | continue; 44 | } 45 | } 46 | if (item2.mnemonic.length() >= 3 && item2.mnemonic.substr(0, 3) == "add") { 47 | std::stringstream fmt; 48 | fmt << "x%d, x" << xCurrentReg << ", #%llx"; 49 | if (sscanf(item2.op_str.c_str(), fmt.str().c_str(), &xFirstRegNum, &xFirstRegOffset) != 2) { 50 | continue; 51 | } 52 | } 53 | 54 | if (xFirstRegOffset) { 55 | break; 56 | } 57 | } 58 | if (xFirstRegOffset == 0) { 59 | break; 60 | } 61 | if (xFirstRegOffset != 0x10) { 62 | v_register_offset.push_back(xFirstRegOffset); 63 | res = true; 64 | break; 65 | } 66 | size_t xSecondRegNum = 0; 67 | size_t xSecondRegOffset = 0; 68 | y = y + 1; 69 | if (y >= v_code_line.size()) { 70 | break; 71 | } 72 | for (; y < v_code_line.size(); y++) { 73 | xSecondRegNum = 0; 74 | xSecondRegOffset = 0; 75 | auto& item2 = v_code_line[y]; 76 | if (item2.mnemonic.length() < 3 || item2.mnemonic.substr(0, 3) != "ldr") { 77 | continue; 78 | } 79 | std::stringstream fmt; 80 | fmt << "x%d, [x" << xFirstRegNum << ", #%llx]"; 81 | if (sscanf(item2.op_str.c_str(), fmt.str().c_str(), &xSecondRegNum, &xSecondRegOffset) != 2) { 82 | continue; 83 | } 84 | if (xSecondRegOffset) { 85 | break; 86 | } 87 | } 88 | if (xSecondRegOffset) { 89 | v_register_offset.push_back(xFirstRegOffset); 90 | v_register_offset.push_back(xSecondRegOffset); 91 | res = true; 92 | break; 93 | } 94 | } 95 | return res; 96 | } 97 | 98 | bool handle_and 99 | (const std::vector& v_code_line, std::vector& v_register_offset) { 100 | bool res = false; 101 | for (auto x = 0; x < v_code_line.size(); x++) { 102 | auto& item = v_code_line[x]; 103 | if (item.mnemonic != "and") { 104 | continue; 105 | } 106 | int xCurrentReg = 0; 107 | int xLastSpReg = 0; 108 | if (sscanf(item.op_str.c_str(), "x%d, x%d, #0xffffffffffffc000", &xCurrentReg, &xLastSpReg) != 2) { 109 | continue; 110 | } 111 | auto y = x + 1; 112 | if (y >= v_code_line.size()) { 113 | break; 114 | } 115 | 116 | size_t xFirstRegNum = 0; 117 | size_t xFirstRegOffset = 0; 118 | 119 | for (; y < v_code_line.size(); y++) { 120 | xFirstRegNum = 0; 121 | xFirstRegOffset = 0; 122 | auto& item2 = v_code_line[y]; 123 | if (item2.mnemonic.length() >= 3 && item2.mnemonic.substr(0, 3) == "ldr") { 124 | std::stringstream fmt; 125 | fmt << "x%d, [x" << xCurrentReg << ", #%llx]"; 126 | if (sscanf(item2.op_str.c_str(), fmt.str().c_str(), &xFirstRegNum, &xFirstRegOffset) != 2) { 127 | continue; 128 | } 129 | } 130 | if (item2.mnemonic.length() >= 3 && item2.mnemonic.substr(0, 3) == "add") { 131 | std::stringstream fmt; 132 | fmt << "x%d, x" << xCurrentReg << ", #%llx"; 133 | if (sscanf(item2.op_str.c_str(), fmt.str().c_str(), &xFirstRegNum, &xFirstRegOffset) != 2) { 134 | continue; 135 | } 136 | } 137 | 138 | if (xFirstRegOffset) { 139 | break; 140 | } 141 | } 142 | if (xFirstRegOffset == 0) { 143 | break; 144 | } 145 | if (xFirstRegOffset != 0x10) { 146 | v_register_offset.push_back(xFirstRegOffset); 147 | res = true; 148 | break; 149 | } 150 | size_t xSecondRegNum = 0; 151 | size_t xSecondRegOffset = 0; 152 | y = y + 1; 153 | if (y >= v_code_line.size()) { 154 | break; 155 | } 156 | for (; y < v_code_line.size(); y++) { 157 | xSecondRegNum = 0; 158 | xSecondRegOffset = 0; 159 | auto& item2 = v_code_line[y]; 160 | if (item2.mnemonic.length() < 3 || item2.mnemonic.substr(0, 3) != "ldr") { 161 | continue; 162 | } 163 | std::stringstream fmt; 164 | fmt << "x%d, [x" << xFirstRegNum << ", #%llx]"; 165 | if (sscanf(item2.op_str.c_str(), fmt.str().c_str(), &xSecondRegNum, &xSecondRegOffset) != 2) { 166 | continue; 167 | } 168 | if (xSecondRegOffset) { 169 | break; 170 | } 171 | } 172 | if (xSecondRegOffset) { 173 | v_register_offset.push_back(xFirstRegOffset); 174 | v_register_offset.push_back(xSecondRegOffset); 175 | res = true; 176 | break; 177 | } 178 | } 179 | return res; 180 | } 181 | 182 | bool handle_current_task_next_register_offset(const std::string& group_name, const std::vector& v_code_line, std::string& mode_name, std::vector& v_register_offset) { 183 | bool _mrs = handle_mrs(v_code_line, v_register_offset); 184 | if (_mrs) { 185 | mode_name = "mrs"; 186 | return _mrs; 187 | } 188 | bool _and = handle_and(v_code_line, v_register_offset); 189 | if (_and) { 190 | mode_name = "and"; 191 | return true; 192 | } 193 | return false; 194 | } 195 | 196 | bool find_current_task_next_register_offset(const std::vector& file_buf, size_t start, std::string & mode_name, std::vector & v_register_offset) { 197 | bool res = false; 198 | csh handle; 199 | cs_err err = cs_open(CS_ARCH_ARM64, CS_MODE_LITTLE_ENDIAN, &handle); 200 | if (err) { 201 | printf("Failed on cs_open() with error returned: %u\n", err); 202 | abort(); 203 | } 204 | cs_option(handle, CS_OPT_DETAIL, CS_OPT_ON); 205 | cs_option(handle, CS_OPT_SKIPDATA, CS_OPT_ON); 206 | //cs_option(handle, CS_OPT_UNSIGNED, CS_OPT_ON); 207 | 208 | cs_insn* insn = cs_malloc(handle); 209 | uint64_t address = 0x0; 210 | const uint8_t* code = (const uint8_t*)&file_buf[0] + start; 211 | size_t file_size = file_buf.size() - start; 212 | std::vector v_code_line; 213 | while (cs_disasm_iter(handle, &code, &file_size, &address, insn)) { 214 | code_line line; 215 | line.addr = insn->address; 216 | line.mnemonic = insn->mnemonic; 217 | line.op_str = insn->op_str; 218 | v_code_line.push_back(line); 219 | 220 | cs_detail* detail = insn->detail; 221 | if (detail->groups_count > 0 && v_code_line.size() >= 2) { 222 | std::string group_name = cs_group_name(handle, detail->groups[0]); 223 | res = handle_current_task_next_register_offset(group_name, v_code_line, mode_name, v_register_offset); 224 | if (res) { 225 | break; 226 | } 227 | } 228 | } 229 | cs_free(insn, 1); 230 | cs_close(&handle); 231 | return res; 232 | } 233 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/include/capstone/tms320c64x.h: -------------------------------------------------------------------------------- 1 | /* Capstone Disassembly Engine */ 2 | /* TMS320C64x Backend by Fotis Loukos 2016 */ 3 | 4 | #ifndef CAPSTONE_TMS320C64X_H 5 | #define CAPSTONE_TMS320C64X_H 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | #include 12 | #include "platform.h" 13 | 14 | #ifdef _MSC_VER 15 | #pragma warning(disable:4201) 16 | #endif 17 | 18 | typedef enum tms320c64x_op_type { 19 | TMS320C64X_OP_INVALID = 0, ///< = CS_OP_INVALID (Uninitialized). 20 | TMS320C64X_OP_REG, ///< = CS_OP_REG (Register operand). 21 | TMS320C64X_OP_IMM, ///< = CS_OP_IMM (Immediate operand). 22 | TMS320C64X_OP_MEM, ///< = CS_OP_MEM (Memory operand). 23 | TMS320C64X_OP_REGPAIR = 64, ///< Register pair for double word ops 24 | } tms320c64x_op_type; 25 | 26 | typedef enum tms320c64x_mem_disp { 27 | TMS320C64X_MEM_DISP_INVALID = 0, 28 | TMS320C64X_MEM_DISP_CONSTANT, 29 | TMS320C64X_MEM_DISP_REGISTER, 30 | } tms320c64x_mem_disp; 31 | 32 | typedef enum tms320c64x_mem_dir { 33 | TMS320C64X_MEM_DIR_INVALID = 0, 34 | TMS320C64X_MEM_DIR_FW, 35 | TMS320C64X_MEM_DIR_BW, 36 | } tms320c64x_mem_dir; 37 | 38 | typedef enum tms320c64x_mem_mod { 39 | TMS320C64X_MEM_MOD_INVALID = 0, 40 | TMS320C64X_MEM_MOD_NO, 41 | TMS320C64X_MEM_MOD_PRE, 42 | TMS320C64X_MEM_MOD_POST, 43 | } tms320c64x_mem_mod; 44 | 45 | typedef struct tms320c64x_op_mem { 46 | unsigned int base; ///< base register 47 | unsigned int disp; ///< displacement/offset value 48 | unsigned int unit; ///< unit of base and offset register 49 | unsigned int scaled; ///< offset scaled 50 | unsigned int disptype; ///< displacement type 51 | unsigned int direction; ///< direction 52 | unsigned int modify; ///< modification 53 | } tms320c64x_op_mem; 54 | 55 | typedef struct cs_tms320c64x_op { 56 | tms320c64x_op_type type; ///< operand type 57 | union { 58 | unsigned int reg; ///< register value for REG operand or first register for REGPAIR operand 59 | int32_t imm; ///< immediate value for IMM operand 60 | tms320c64x_op_mem mem; ///< base/disp value for MEM operand 61 | }; 62 | } cs_tms320c64x_op; 63 | 64 | typedef struct cs_tms320c64x { 65 | uint8_t op_count; 66 | cs_tms320c64x_op operands[8]; ///< operands for this instruction. 67 | struct { 68 | unsigned int reg; 69 | unsigned int zero; 70 | } condition; 71 | struct { 72 | unsigned int unit; 73 | unsigned int side; 74 | unsigned int crosspath; 75 | } funit; 76 | unsigned int parallel; 77 | } cs_tms320c64x; 78 | 79 | typedef enum tms320c64x_reg { 80 | TMS320C64X_REG_INVALID = 0, 81 | 82 | TMS320C64X_REG_AMR, 83 | TMS320C64X_REG_CSR, 84 | TMS320C64X_REG_DIER, 85 | TMS320C64X_REG_DNUM, 86 | TMS320C64X_REG_ECR, 87 | TMS320C64X_REG_GFPGFR, 88 | TMS320C64X_REG_GPLYA, 89 | TMS320C64X_REG_GPLYB, 90 | TMS320C64X_REG_ICR, 91 | TMS320C64X_REG_IER, 92 | TMS320C64X_REG_IERR, 93 | TMS320C64X_REG_ILC, 94 | TMS320C64X_REG_IRP, 95 | TMS320C64X_REG_ISR, 96 | TMS320C64X_REG_ISTP, 97 | TMS320C64X_REG_ITSR, 98 | TMS320C64X_REG_NRP, 99 | TMS320C64X_REG_NTSR, 100 | TMS320C64X_REG_REP, 101 | TMS320C64X_REG_RILC, 102 | TMS320C64X_REG_SSR, 103 | TMS320C64X_REG_TSCH, 104 | TMS320C64X_REG_TSCL, 105 | TMS320C64X_REG_TSR, 106 | TMS320C64X_REG_A0, 107 | TMS320C64X_REG_A1, 108 | TMS320C64X_REG_A2, 109 | TMS320C64X_REG_A3, 110 | TMS320C64X_REG_A4, 111 | TMS320C64X_REG_A5, 112 | TMS320C64X_REG_A6, 113 | TMS320C64X_REG_A7, 114 | TMS320C64X_REG_A8, 115 | TMS320C64X_REG_A9, 116 | TMS320C64X_REG_A10, 117 | TMS320C64X_REG_A11, 118 | TMS320C64X_REG_A12, 119 | TMS320C64X_REG_A13, 120 | TMS320C64X_REG_A14, 121 | TMS320C64X_REG_A15, 122 | TMS320C64X_REG_A16, 123 | TMS320C64X_REG_A17, 124 | TMS320C64X_REG_A18, 125 | TMS320C64X_REG_A19, 126 | TMS320C64X_REG_A20, 127 | TMS320C64X_REG_A21, 128 | TMS320C64X_REG_A22, 129 | TMS320C64X_REG_A23, 130 | TMS320C64X_REG_A24, 131 | TMS320C64X_REG_A25, 132 | TMS320C64X_REG_A26, 133 | TMS320C64X_REG_A27, 134 | TMS320C64X_REG_A28, 135 | TMS320C64X_REG_A29, 136 | TMS320C64X_REG_A30, 137 | TMS320C64X_REG_A31, 138 | TMS320C64X_REG_B0, 139 | TMS320C64X_REG_B1, 140 | TMS320C64X_REG_B2, 141 | TMS320C64X_REG_B3, 142 | TMS320C64X_REG_B4, 143 | TMS320C64X_REG_B5, 144 | TMS320C64X_REG_B6, 145 | TMS320C64X_REG_B7, 146 | TMS320C64X_REG_B8, 147 | TMS320C64X_REG_B9, 148 | TMS320C64X_REG_B10, 149 | TMS320C64X_REG_B11, 150 | TMS320C64X_REG_B12, 151 | TMS320C64X_REG_B13, 152 | TMS320C64X_REG_B14, 153 | TMS320C64X_REG_B15, 154 | TMS320C64X_REG_B16, 155 | TMS320C64X_REG_B17, 156 | TMS320C64X_REG_B18, 157 | TMS320C64X_REG_B19, 158 | TMS320C64X_REG_B20, 159 | TMS320C64X_REG_B21, 160 | TMS320C64X_REG_B22, 161 | TMS320C64X_REG_B23, 162 | TMS320C64X_REG_B24, 163 | TMS320C64X_REG_B25, 164 | TMS320C64X_REG_B26, 165 | TMS320C64X_REG_B27, 166 | TMS320C64X_REG_B28, 167 | TMS320C64X_REG_B29, 168 | TMS320C64X_REG_B30, 169 | TMS320C64X_REG_B31, 170 | TMS320C64X_REG_PCE1, 171 | 172 | TMS320C64X_REG_ENDING, // <-- mark the end of the list of registers 173 | 174 | // Alias registers 175 | TMS320C64X_REG_EFR = TMS320C64X_REG_ECR, 176 | TMS320C64X_REG_IFR = TMS320C64X_REG_ISR, 177 | } tms320c64x_reg; 178 | 179 | typedef enum tms320c64x_insn { 180 | TMS320C64X_INS_INVALID = 0, 181 | 182 | TMS320C64X_INS_ABS, 183 | TMS320C64X_INS_ABS2, 184 | TMS320C64X_INS_ADD, 185 | TMS320C64X_INS_ADD2, 186 | TMS320C64X_INS_ADD4, 187 | TMS320C64X_INS_ADDAB, 188 | TMS320C64X_INS_ADDAD, 189 | TMS320C64X_INS_ADDAH, 190 | TMS320C64X_INS_ADDAW, 191 | TMS320C64X_INS_ADDK, 192 | TMS320C64X_INS_ADDKPC, 193 | TMS320C64X_INS_ADDU, 194 | TMS320C64X_INS_AND, 195 | TMS320C64X_INS_ANDN, 196 | TMS320C64X_INS_AVG2, 197 | TMS320C64X_INS_AVGU4, 198 | TMS320C64X_INS_B, 199 | TMS320C64X_INS_BDEC, 200 | TMS320C64X_INS_BITC4, 201 | TMS320C64X_INS_BNOP, 202 | TMS320C64X_INS_BPOS, 203 | TMS320C64X_INS_CLR, 204 | TMS320C64X_INS_CMPEQ, 205 | TMS320C64X_INS_CMPEQ2, 206 | TMS320C64X_INS_CMPEQ4, 207 | TMS320C64X_INS_CMPGT, 208 | TMS320C64X_INS_CMPGT2, 209 | TMS320C64X_INS_CMPGTU4, 210 | TMS320C64X_INS_CMPLT, 211 | TMS320C64X_INS_CMPLTU, 212 | TMS320C64X_INS_DEAL, 213 | TMS320C64X_INS_DOTP2, 214 | TMS320C64X_INS_DOTPN2, 215 | TMS320C64X_INS_DOTPNRSU2, 216 | TMS320C64X_INS_DOTPRSU2, 217 | TMS320C64X_INS_DOTPSU4, 218 | TMS320C64X_INS_DOTPU4, 219 | TMS320C64X_INS_EXT, 220 | TMS320C64X_INS_EXTU, 221 | TMS320C64X_INS_GMPGTU, 222 | TMS320C64X_INS_GMPY4, 223 | TMS320C64X_INS_LDB, 224 | TMS320C64X_INS_LDBU, 225 | TMS320C64X_INS_LDDW, 226 | TMS320C64X_INS_LDH, 227 | TMS320C64X_INS_LDHU, 228 | TMS320C64X_INS_LDNDW, 229 | TMS320C64X_INS_LDNW, 230 | TMS320C64X_INS_LDW, 231 | TMS320C64X_INS_LMBD, 232 | TMS320C64X_INS_MAX2, 233 | TMS320C64X_INS_MAXU4, 234 | TMS320C64X_INS_MIN2, 235 | TMS320C64X_INS_MINU4, 236 | TMS320C64X_INS_MPY, 237 | TMS320C64X_INS_MPY2, 238 | TMS320C64X_INS_MPYH, 239 | TMS320C64X_INS_MPYHI, 240 | TMS320C64X_INS_MPYHIR, 241 | TMS320C64X_INS_MPYHL, 242 | TMS320C64X_INS_MPYHLU, 243 | TMS320C64X_INS_MPYHSLU, 244 | TMS320C64X_INS_MPYHSU, 245 | TMS320C64X_INS_MPYHU, 246 | TMS320C64X_INS_MPYHULS, 247 | TMS320C64X_INS_MPYHUS, 248 | TMS320C64X_INS_MPYLH, 249 | TMS320C64X_INS_MPYLHU, 250 | TMS320C64X_INS_MPYLI, 251 | TMS320C64X_INS_MPYLIR, 252 | TMS320C64X_INS_MPYLSHU, 253 | TMS320C64X_INS_MPYLUHS, 254 | TMS320C64X_INS_MPYSU, 255 | TMS320C64X_INS_MPYSU4, 256 | TMS320C64X_INS_MPYU, 257 | TMS320C64X_INS_MPYU4, 258 | TMS320C64X_INS_MPYUS, 259 | TMS320C64X_INS_MVC, 260 | TMS320C64X_INS_MVD, 261 | TMS320C64X_INS_MVK, 262 | TMS320C64X_INS_MVKL, 263 | TMS320C64X_INS_MVKLH, 264 | TMS320C64X_INS_NOP, 265 | TMS320C64X_INS_NORM, 266 | TMS320C64X_INS_OR, 267 | TMS320C64X_INS_PACK2, 268 | TMS320C64X_INS_PACKH2, 269 | TMS320C64X_INS_PACKH4, 270 | TMS320C64X_INS_PACKHL2, 271 | TMS320C64X_INS_PACKL4, 272 | TMS320C64X_INS_PACKLH2, 273 | TMS320C64X_INS_ROTL, 274 | TMS320C64X_INS_SADD, 275 | TMS320C64X_INS_SADD2, 276 | TMS320C64X_INS_SADDU4, 277 | TMS320C64X_INS_SADDUS2, 278 | TMS320C64X_INS_SAT, 279 | TMS320C64X_INS_SET, 280 | TMS320C64X_INS_SHFL, 281 | TMS320C64X_INS_SHL, 282 | TMS320C64X_INS_SHLMB, 283 | TMS320C64X_INS_SHR, 284 | TMS320C64X_INS_SHR2, 285 | TMS320C64X_INS_SHRMB, 286 | TMS320C64X_INS_SHRU, 287 | TMS320C64X_INS_SHRU2, 288 | TMS320C64X_INS_SMPY, 289 | TMS320C64X_INS_SMPY2, 290 | TMS320C64X_INS_SMPYH, 291 | TMS320C64X_INS_SMPYHL, 292 | TMS320C64X_INS_SMPYLH, 293 | TMS320C64X_INS_SPACK2, 294 | TMS320C64X_INS_SPACKU4, 295 | TMS320C64X_INS_SSHL, 296 | TMS320C64X_INS_SSHVL, 297 | TMS320C64X_INS_SSHVR, 298 | TMS320C64X_INS_SSUB, 299 | TMS320C64X_INS_STB, 300 | TMS320C64X_INS_STDW, 301 | TMS320C64X_INS_STH, 302 | TMS320C64X_INS_STNDW, 303 | TMS320C64X_INS_STNW, 304 | TMS320C64X_INS_STW, 305 | TMS320C64X_INS_SUB, 306 | TMS320C64X_INS_SUB2, 307 | TMS320C64X_INS_SUB4, 308 | TMS320C64X_INS_SUBAB, 309 | TMS320C64X_INS_SUBABS4, 310 | TMS320C64X_INS_SUBAH, 311 | TMS320C64X_INS_SUBAW, 312 | TMS320C64X_INS_SUBC, 313 | TMS320C64X_INS_SUBU, 314 | TMS320C64X_INS_SWAP4, 315 | TMS320C64X_INS_UNPKHU4, 316 | TMS320C64X_INS_UNPKLU4, 317 | TMS320C64X_INS_XOR, 318 | TMS320C64X_INS_XPND2, 319 | TMS320C64X_INS_XPND4, 320 | // Aliases 321 | TMS320C64X_INS_IDLE, 322 | TMS320C64X_INS_MV, 323 | TMS320C64X_INS_NEG, 324 | TMS320C64X_INS_NOT, 325 | TMS320C64X_INS_SWAP2, 326 | TMS320C64X_INS_ZERO, 327 | 328 | TMS320C64X_INS_ENDING, // <-- mark the end of the list of instructions 329 | } tms320c64x_insn; 330 | 331 | typedef enum tms320c64x_insn_group { 332 | TMS320C64X_GRP_INVALID = 0, ///< = CS_GRP_INVALID 333 | 334 | TMS320C64X_GRP_JUMP, ///< = CS_GRP_JUMP 335 | 336 | TMS320C64X_GRP_FUNIT_D = 128, 337 | TMS320C64X_GRP_FUNIT_L, 338 | TMS320C64X_GRP_FUNIT_M, 339 | TMS320C64X_GRP_FUNIT_S, 340 | TMS320C64X_GRP_FUNIT_NO, 341 | 342 | TMS320C64X_GRP_ENDING, // <-- mark the end of the list of groups 343 | } tms320c64x_insn_group; 344 | 345 | typedef enum tms320c64x_funit { 346 | TMS320C64X_FUNIT_INVALID = 0, 347 | TMS320C64X_FUNIT_D, 348 | TMS320C64X_FUNIT_L, 349 | TMS320C64X_FUNIT_M, 350 | TMS320C64X_FUNIT_S, 351 | TMS320C64X_FUNIT_NO 352 | } tms320c64x_funit; 353 | 354 | #ifdef __cplusplus 355 | } 356 | #endif 357 | 358 | #endif 359 | 360 | -------------------------------------------------------------------------------- /patch_kernel_root/kallsyms_lookup_name.cpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "kallsyms_lookup_name.h" 3 | #include "base_func.h" 4 | 5 | #ifndef MIN 6 | #define MIN(x, y)(x < y) ? (x) : (y) 7 | #endif // !MIN 8 | 9 | #define MAX_FIND_RANGE 0x1000 10 | namespace { 11 | const int KSYM_NAME_LEN = 128; 12 | } 13 | KallsymsLookupName::KallsymsLookupName(const std::vector& file_buf) : m_file_buf(file_buf) 14 | { 15 | } 16 | 17 | KallsymsLookupName::~KallsymsLookupName() 18 | { 19 | } 20 | 21 | bool KallsymsLookupName::init() { 22 | size_t addresses_list_start = 0, addresses_list_end = 0; 23 | if (!find_kallsyms_addresses_list(addresses_list_start, addresses_list_end)) { 24 | std::cout << "Unable to find the list of kallsyms addresses" << std::endl; 25 | return false; 26 | } 27 | size_t kallsyms_num_offset = 0; 28 | m_kallsyms_num = find_kallsyms_num(addresses_list_start, addresses_list_end, kallsyms_num_offset); 29 | if (!m_kallsyms_num) { 30 | std::cout << "Unable to find the num of kallsyms addresses list" << std::endl; 31 | return false; 32 | } 33 | std::cout << std::hex << "kallsyms_num: 0x" << m_kallsyms_num << std::endl; 34 | 35 | 36 | addresses_list_start = addresses_list_end - m_kallsyms_num * sizeof(uint64_t); 37 | std::cout << std::hex << "kallsyms_addresses_start: 0x" << addresses_list_start << std::endl; 38 | std::cout << std::hex << "kallsyms_addresses_end: 0x" << addresses_list_end << std::endl; 39 | m_kallsyms_addresses.offset = addresses_list_start; 40 | 41 | size_t kallsyms_num_end_offset = kallsyms_num_offset + sizeof(m_kallsyms_num); 42 | size_t name_list_start = 0, name_list_end = 0; 43 | if (!find_kallsyms_names_list(m_kallsyms_num, kallsyms_num_end_offset, name_list_start, name_list_end)) { 44 | std::cout << "Unable to find the list of kallsyms names list" << std::endl; 45 | return false; 46 | } 47 | std::cout << std::hex << "kallsyms_names_start: 0x" << name_list_start << std::endl; 48 | std::cout << std::hex << "kallsyms_names_end: 0x" << name_list_end << std::endl; 49 | m_kallsyms_names.offset = name_list_start; 50 | 51 | size_t markers_list_start = 0; 52 | size_t markers_list_end = 0; 53 | if (!find_kallsyms_markers_list(m_kallsyms_num, name_list_end, markers_list_start, markers_list_end)) { 54 | std::cout << "Unable to find the list of kallsyms markers list" << std::endl; 55 | return false; 56 | } 57 | std::cout << std::hex << "kallsyms_markers_start: 0x" << markers_list_start << std::endl; 58 | std::cout << std::hex << "kallsyms_markers_end: 0x" << markers_list_end << std::endl; 59 | m_kallsyms_markers.offset = markers_list_start; 60 | 61 | size_t token_table_start = 0; 62 | size_t token_table_end = 0; 63 | if (!find_kallsyms_token_table(markers_list_end, token_table_start, token_table_end)) { 64 | std::cout << "Unable to find the list of kallsyms token table" << std::endl; 65 | return false; 66 | } 67 | std::cout << std::hex << "kallsyms_token_table_start: 0x" << token_table_start << std::endl; 68 | std::cout << std::hex << "kallsyms_token_table_end: 0x" << token_table_end << std::endl; 69 | m_kallsyms_token_table.offset = token_table_start; 70 | 71 | size_t token_index_start = 0; 72 | if (!find_kallsyms_token_index(token_table_end, token_index_start)) { 73 | std::cout << "Unable to find the list of kallsyms token index" << std::endl; 74 | return false; 75 | } 76 | std::cout << std::hex << "kallsyms_token_index_start: 0x" << token_index_start << std::endl; 77 | m_kallsyms_token_index.offset = token_index_start; 78 | 79 | size_t kallsyms_sym_func_entry_offset = 0; 80 | if (!find_kallsyms_sym_func_entry_offset(kallsyms_sym_func_entry_offset)) { 81 | std::cout << "Unable to find the list of kallsyms sym function entry offset" << std::endl; 82 | return false; 83 | } 84 | std::cout << std::hex << "kallsyms_sym_func_entry_offset: 0x" << kallsyms_sym_func_entry_offset << std::endl; 85 | m_kallsyms_sym_func_entry_offset = kallsyms_sym_func_entry_offset; 86 | 87 | m_inited = true; 88 | return true; 89 | } 90 | 91 | bool KallsymsLookupName::is_inited() { 92 | return m_inited; 93 | } 94 | 95 | int KallsymsLookupName::get_kallsyms_num() { 96 | return m_kallsyms_num; 97 | } 98 | bool KallsymsLookupName::find_kallsyms_addresses_list(size_t& start, size_t& end) { 99 | const int var_len = sizeof(uint64_t); 100 | for (auto x = 0; x + var_len < m_file_buf.size(); x += var_len) { 101 | uint64_t val1 = *(uint64_t*)&m_file_buf[x]; 102 | uint64_t val2 = *(uint64_t*)&m_file_buf[x + var_len]; 103 | if (val1 != 0 || val1 >= val2) { 104 | continue; 105 | } 106 | int cnt = 0; 107 | auto j = x + var_len; 108 | for (; j + var_len < m_file_buf.size(); j += var_len) { 109 | val1 = *(uint64_t*)&m_file_buf[j]; 110 | val2 = *(uint64_t*)&m_file_buf[j + var_len]; 111 | if (val1 > val2 || val2 == 0 || val2 == 0x1000000000000000) { 112 | j += var_len; 113 | break; 114 | } 115 | cnt++; 116 | } 117 | if (cnt >= 0x10000) { 118 | start = x; 119 | end = j; 120 | return true; 121 | } 122 | } 123 | return false; 124 | } 125 | 126 | int KallsymsLookupName::find_kallsyms_num(size_t addresses_list_start, size_t addresses_list_end, size_t& kallsyms_num_offset) { 127 | size_t size = (addresses_list_end - addresses_list_start) / sizeof(uint64_t); 128 | size_t allow_min_size = size - 10; 129 | size_t allow_max_size = size + 10; 130 | auto _min = MIN(m_file_buf.size(), MAX_FIND_RANGE); 131 | int cnt = 10; 132 | for (size_t x = 0; (x + sizeof(int)) < _min; x++) { 133 | auto pos = addresses_list_end + x * sizeof(int); 134 | int val = *(int*)&m_file_buf[pos]; 135 | if (val == 0) { 136 | continue; 137 | } 138 | if (val >= allow_min_size && val < allow_max_size) { 139 | kallsyms_num_offset = pos; 140 | return val; 141 | } 142 | if (--cnt == 0) { 143 | break; 144 | } 145 | } 146 | return 0; 147 | } 148 | 149 | 150 | bool KallsymsLookupName::find_kallsyms_names_list(int kallsyms_num, size_t kallsyms_num_end_offset, size_t& name_list_start, size_t& name_list_end) { 151 | 152 | name_list_start = 0; 153 | name_list_end = 0; 154 | size_t x = kallsyms_num_end_offset; 155 | auto _min = MIN(m_file_buf.size(), x + MAX_FIND_RANGE); 156 | for (; (x + sizeof(char)) < _min; x++) { 157 | char val = *(char*)&m_file_buf[x]; 158 | if (val == '\0') { 159 | continue; 160 | } 161 | name_list_start = x; 162 | break; 163 | } 164 | size_t off = name_list_start; 165 | for (int i = 0; i < kallsyms_num; i++) { 166 | unsigned char ch = (unsigned char)m_file_buf[off++]; 167 | off += ch; 168 | } 169 | name_list_end = off; 170 | return true; 171 | } 172 | 173 | 174 | bool KallsymsLookupName::find_kallsyms_markers_list(int kallsyms_num, size_t name_list_end_offset, size_t& markers_list_start, size_t& markers_list_end) { 175 | size_t start = align8(name_list_end_offset); 176 | const int var_len = sizeof(long); 177 | for (auto x = start; x + var_len < m_file_buf.size(); x += var_len) { 178 | long val1 = *(long*)&m_file_buf[x]; 179 | long val2 = *(long*)&m_file_buf[x + var_len]; 180 | if (val1 == 0 && val2 > 0) { 181 | markers_list_start = x; 182 | break; 183 | } 184 | else if (val1 == 0 && val2 == 0) { 185 | continue; 186 | } 187 | return false; 188 | } 189 | 190 | auto exist_val_start = markers_list_start + var_len; 191 | 192 | bool is_align8 = false; 193 | int cnt = 5; 194 | long last_second_var_val = 0; 195 | for (auto y = markers_list_start + var_len; y + var_len < m_file_buf.size(); y += var_len * 2) { 196 | long val1 = *(long*)&m_file_buf[y]; 197 | long val2 = *(long*)&m_file_buf[y + var_len]; 198 | if (val2 != last_second_var_val) { 199 | break; 200 | } 201 | last_second_var_val = val2; 202 | cnt--; 203 | if (cnt == 0) { 204 | is_align8 = true; 205 | break; 206 | } 207 | } 208 | if (is_align8) { 209 | size_t back_val = align8(markers_list_start) - markers_list_start; 210 | if (back_val == 0) { 211 | markers_list_start -= 8; 212 | } 213 | else { 214 | markers_list_start -= back_val; // 4 215 | } 216 | markers_list_end = markers_list_start + ((kallsyms_num + 255) >> 8) * sizeof(long) * 2; 217 | } 218 | else { 219 | markers_list_end = markers_list_start + ((kallsyms_num + 255) >> 8) * sizeof(long); 220 | } 221 | 222 | return true; 223 | } 224 | 225 | bool KallsymsLookupName::find_kallsyms_token_table(size_t markers_list_end_offset, size_t& kallsyms_token_table_start, size_t& kallsyms_token_table_end) { 226 | size_t start = align8(markers_list_end_offset); 227 | const int var_len = sizeof(long); 228 | for (auto x = start; x + var_len < m_file_buf.size(); x += var_len) { 229 | long val1 = *(long*)&m_file_buf[x]; 230 | if (val1 == 0) { 231 | continue; 232 | } 233 | size_t off = x; 234 | for (unsigned int i = 0; i < 256; i++) { 235 | const char* str = (const char*)&m_file_buf[off]; 236 | off += strlen(str) + 1; 237 | } 238 | kallsyms_token_table_start = x; 239 | kallsyms_token_table_end = off; 240 | return true; 241 | } 242 | return false; 243 | } 244 | 245 | bool KallsymsLookupName::find_kallsyms_token_index(size_t kallsyms_token_table_end, size_t& kallsyms_token_index_start) { 246 | size_t start = align8(kallsyms_token_table_end); 247 | const int var_len = sizeof(short); 248 | for (auto x = start; x + var_len < m_file_buf.size(); x += var_len) { 249 | short val1 = *(short*)&m_file_buf[x]; 250 | short val2 = *(short*)&m_file_buf[x + var_len]; 251 | if (val1 == 0 && val2 > 0) { 252 | kallsyms_token_index_start = x; 253 | break; 254 | } 255 | else if (val1 == 0 && val2 == 0) { 256 | continue; 257 | } 258 | return false; 259 | } 260 | return true; 261 | } 262 | 263 | bool KallsymsLookupName::find_kallsyms_sym_func_entry_offset(size_t& kallsyms_sym_func_entry_offset) { 264 | size_t _text_offset = __kallsyms_lookup_name("_text"); 265 | if (_text_offset == 0) { 266 | return false; 267 | } 268 | m_text_offset = _text_offset; 269 | 270 | size_t _stext_offset = __kallsyms_lookup_name("_stext"); 271 | const int var_len = sizeof(int); 272 | for (auto x = _stext_offset; x + var_len < m_file_buf.size(); x += var_len) { 273 | int val1 = *(int*)&m_file_buf[x]; 274 | if (val1 == 0) { 275 | continue; 276 | } 277 | kallsyms_sym_func_entry_offset = x - _stext_offset; 278 | break; 279 | } 280 | return true; 281 | } 282 | 283 | /* 284 | * Expand a compressed symbol data into the resulting uncompressed string, 285 | * if uncompressed string is too long (>= maxlen), it will be truncated, 286 | * given the offset to where the symbol is in the compressed stream. 287 | */ 288 | unsigned int KallsymsLookupName::kallsyms_expand_symbol(unsigned int off, char* result, size_t maxlen) 289 | { 290 | int len, skipped_first = 0; 291 | const char* tptr; 292 | const uint8_t* data; 293 | 294 | /* Get the compressed symbol length from the first symbol byte. */ 295 | 296 | data = (uint8_t*)&m_file_buf[m_kallsyms_names.offset + off * sizeof(uint8_t)]; 297 | 298 | len = *data; 299 | data++; 300 | 301 | /* 302 | * Update the offset to return the offset for the next symbol on 303 | * the compressed stream. 304 | */ 305 | off += len + 1; 306 | 307 | /* 308 | * For every byte on the compressed symbol data, copy the table 309 | * entry for that byte. 310 | */ 311 | 312 | while (len) { 313 | uint8_t x = *data; 314 | short y = *(short*)&m_file_buf[m_kallsyms_token_index.offset + x * sizeof(uint16_t)]; 315 | 316 | tptr = &m_file_buf[m_kallsyms_token_table.offset + y * sizeof(unsigned char)]; 317 | data++; 318 | len--; 319 | 320 | while (*tptr) { 321 | if (skipped_first) { 322 | if (maxlen <= 1) 323 | goto tail; 324 | *result = *tptr; 325 | result++; 326 | maxlen--; 327 | } 328 | else 329 | skipped_first = 1; 330 | tptr++; 331 | } 332 | } 333 | 334 | tail: 335 | if (maxlen) 336 | *result = '\0'; 337 | 338 | /* Return to offset to the next symbol. */ 339 | return off; 340 | } 341 | 342 | /* Lookup the address for this symbol. Returns 0 if not found. */ 343 | uint64_t KallsymsLookupName::__kallsyms_lookup_name(const char* name, bool include_str_mode) { 344 | for (auto i = 0, off = 0; i < m_kallsyms_num; i++) { 345 | char namebuf[KSYM_NAME_LEN] = { 0 }; 346 | off = kallsyms_expand_symbol(off, namebuf, sizeof(namebuf)); 347 | 348 | //std::cout << namebuf << std::endl; 349 | if (strcmp(namebuf, name) == 0 || (include_str_mode && strstr(namebuf, name))) { 350 | auto pos = m_kallsyms_addresses.offset + i * sizeof(uint64_t); 351 | uint64_t offset = *(uint64_t*)&m_file_buf[pos]; 352 | offset -= m_text_offset; 353 | offset += m_kallsyms_sym_func_entry_offset; 354 | return offset; 355 | } 356 | } 357 | return 0; 358 | } 359 | 360 | uint64_t KallsymsLookupName::kallsyms_lookup_name(const char* name, bool include_str_mode) { 361 | if (!m_inited) { return 0; } 362 | return __kallsyms_lookup_name(name, include_str_mode); 363 | } 364 | -------------------------------------------------------------------------------- /patch_kernel_root/kallsyms_lookup_name_4_6_0.cpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "kallsyms_lookup_name_4_6_0.h" 3 | #include "base_func.h" 4 | 5 | #ifndef MIN 6 | #define MIN(x, y)(x < y) ? (x) : (y) 7 | #endif // !MIN 8 | 9 | #define MAX_FIND_RANGE 0x1000 10 | namespace { 11 | const int KSYM_NAME_LEN = 128; 12 | } 13 | KallsymsLookupName_4_6_0::KallsymsLookupName_4_6_0(const std::vector& file_buf) : m_file_buf(file_buf) 14 | { 15 | } 16 | 17 | KallsymsLookupName_4_6_0::~KallsymsLookupName_4_6_0() 18 | { 19 | } 20 | 21 | bool KallsymsLookupName_4_6_0::init() { 22 | size_t offset_list_start = 0, offset_list_end = 0; 23 | if (!find_kallsyms_offsets_list(offset_list_start, offset_list_end)) { 24 | std::cout << "Unable to find the list of kallsyms offsets" << std::endl; 25 | return false; 26 | } 27 | size_t kallsyms_num_offset = 0; 28 | m_kallsyms_num = find_kallsyms_num(offset_list_start, offset_list_end, kallsyms_num_offset); 29 | if (!m_kallsyms_num) { 30 | std::cout << "Unable to find the num of kallsyms offset list" << std::endl; 31 | return false; 32 | } 33 | 34 | std::cout << std::hex << "kallsyms_num: 0x" << m_kallsyms_num << std::endl; 35 | 36 | // revise the offset list offset again 37 | const int offset_list_var_len = sizeof(long); 38 | offset_list_start = offset_list_end - m_kallsyms_num * offset_list_var_len; 39 | long test_first_offset_list_val; 40 | do { 41 | test_first_offset_list_val = *(long*)&m_file_buf[offset_list_start]; 42 | if (test_first_offset_list_val) { 43 | offset_list_start -= offset_list_var_len; 44 | offset_list_end -= offset_list_var_len; 45 | } 46 | } while (test_first_offset_list_val); 47 | 48 | std::cout << std::hex << "kallsyms_offset_start: 0x" << offset_list_start << std::endl; 49 | std::cout << std::hex << "kallsyms_offset_end: 0x" << offset_list_end << std::endl; 50 | m_kallsyms_offsets.offset = offset_list_start; 51 | 52 | size_t kallsyms_num_end_offset = kallsyms_num_offset + sizeof(m_kallsyms_num); 53 | size_t name_list_start = 0, name_list_end = 0; 54 | if (!find_kallsyms_names_list(m_kallsyms_num, kallsyms_num_end_offset, name_list_start, name_list_end)) { 55 | std::cout << "Unable to find the list of kallsyms names list" << std::endl; 56 | return false; 57 | } 58 | std::cout << std::hex << "kallsyms_names_start: 0x" << name_list_start << std::endl; 59 | std::cout << std::hex << "kallsyms_names_end: 0x" << name_list_end << std::endl; 60 | m_kallsyms_names.offset = name_list_start; 61 | 62 | size_t markers_list_start = 0; 63 | size_t markers_list_end = 0; 64 | if (!find_kallsyms_markers_list(m_kallsyms_num, name_list_end, markers_list_start, markers_list_end)) { 65 | std::cout << "Unable to find the list of kallsyms markers list" << std::endl; 66 | return false; 67 | } 68 | std::cout << std::hex << "kallsyms_markers_start: 0x" << markers_list_start << std::endl; 69 | std::cout << std::hex << "kallsyms_markers_end: 0x" << markers_list_end << std::endl; 70 | m_kallsyms_markers.offset = markers_list_start; 71 | 72 | size_t token_table_start = 0; 73 | size_t token_table_end = 0; 74 | if (!find_kallsyms_token_table(markers_list_end, token_table_start, token_table_end)) { 75 | std::cout << "Unable to find the list of kallsyms token table" << std::endl; 76 | return false; 77 | } 78 | std::cout << std::hex << "kallsyms_token_table_start: 0x" << token_table_start << std::endl; 79 | std::cout << std::hex << "kallsyms_token_table_end: 0x" << token_table_end << std::endl; 80 | m_kallsyms_token_table.offset = token_table_start; 81 | 82 | size_t token_index_start = 0; 83 | if (!find_kallsyms_token_index(token_table_end, token_index_start)) { 84 | std::cout << "Unable to find the list of kallsyms token index" << std::endl; 85 | return false; 86 | } 87 | std::cout << std::hex << "kallsyms_token_index_start: 0x" << token_index_start << std::endl; 88 | m_kallsyms_token_index.offset = token_index_start; 89 | 90 | size_t kallsyms_sym_func_entry_offset = 0; 91 | if (!find_kallsyms_sym_func_entry_offset(kallsyms_sym_func_entry_offset)) { 92 | std::cout << "Unable to find the list of kallsyms sym function entry offset" << std::endl; 93 | return false; 94 | } 95 | std::cout << std::hex << "kallsyms_sym_func_entry_offset: 0x" << kallsyms_sym_func_entry_offset << std::endl; 96 | m_kallsyms_sym_func_entry_offset = kallsyms_sym_func_entry_offset; 97 | 98 | m_inited = true; 99 | return true; 100 | } 101 | 102 | bool KallsymsLookupName_4_6_0::is_inited() { 103 | return m_inited; 104 | } 105 | 106 | int KallsymsLookupName_4_6_0::get_kallsyms_num() { 107 | return m_kallsyms_num; 108 | } 109 | bool KallsymsLookupName_4_6_0::find_kallsyms_offsets_list(size_t& start, size_t& end) { 110 | const int var_len = sizeof(long); 111 | for (auto x = 0; x + var_len < m_file_buf.size(); x += var_len) { 112 | long val1 = *(long*)&m_file_buf[x]; 113 | long val2 = *(long*)&m_file_buf[x + var_len]; 114 | if (val1 != 0 || val1 >= val2) { 115 | continue; 116 | } 117 | int cnt = 0; 118 | auto j = x + var_len; 119 | for (; j + var_len < m_file_buf.size(); j += var_len) { 120 | val1 = *(long*)&m_file_buf[j]; 121 | val2 = *(long*)&m_file_buf[j + var_len]; 122 | if (val1 > val2 || val2 == 0 || (val2 - val1) > 0x1000000) { 123 | j += var_len; 124 | break; 125 | } 126 | cnt++; 127 | } 128 | if (cnt >= 0x10000) { 129 | start = x; 130 | end = j; 131 | return true; 132 | } 133 | } 134 | return false; 135 | } 136 | 137 | int KallsymsLookupName_4_6_0::find_kallsyms_num(size_t offset_list_start, size_t offset_list_end, size_t& kallsyms_num_offset) { 138 | size_t size = (offset_list_end - offset_list_start) / sizeof(int); 139 | size_t allow_min_size = size - 10; 140 | size_t allow_max_size = size + 10; 141 | auto _min = MIN(m_file_buf.size(), MAX_FIND_RANGE); 142 | int cnt = 10; 143 | for (size_t x = 0; (x + sizeof(int)) < _min; x++) { 144 | auto pos = offset_list_end + x * sizeof(int); 145 | int val = *(int*)&m_file_buf[pos]; 146 | if (val == 0) { 147 | continue; 148 | } 149 | if (val >= allow_min_size && val < allow_max_size) { 150 | kallsyms_num_offset = pos; 151 | return val; 152 | } 153 | if (--cnt == 0) { 154 | break; 155 | } 156 | } 157 | return 0; 158 | } 159 | 160 | 161 | bool KallsymsLookupName_4_6_0::find_kallsyms_names_list(int kallsyms_num, size_t kallsyms_num_end_offset, size_t& name_list_start, size_t& name_list_end) { 162 | 163 | name_list_start = 0; 164 | name_list_end = 0; 165 | size_t x = kallsyms_num_end_offset; 166 | auto _min = MIN(m_file_buf.size(), x + MAX_FIND_RANGE); 167 | for (; (x + sizeof(char)) < _min; x++) { 168 | char val = *(char*)&m_file_buf[x]; 169 | if (val == '\0') { 170 | continue; 171 | } 172 | name_list_start = x; 173 | break; 174 | } 175 | size_t off = name_list_start; 176 | for (int i = 0; i < kallsyms_num; i++) { 177 | unsigned char ch = (unsigned char)m_file_buf[off++]; 178 | off += ch; 179 | } 180 | name_list_end = off; 181 | return true; 182 | } 183 | 184 | 185 | bool KallsymsLookupName_4_6_0::find_kallsyms_markers_list(int kallsyms_num, size_t name_list_end_offset, size_t& markers_list_start, size_t& markers_list_end) { 186 | size_t start = align8(name_list_end_offset); 187 | const int var_len = sizeof(long); 188 | for (auto x = start; x + var_len < m_file_buf.size(); x += var_len) { 189 | long val1 = *(long*)&m_file_buf[x]; 190 | long val2 = *(long*)&m_file_buf[x + var_len]; 191 | if (val1 == 0 && val2 > 0) { 192 | markers_list_start = x; 193 | break; 194 | } else if (val1 == 0 && val2 == 0) { 195 | continue; 196 | } 197 | return false; 198 | } 199 | 200 | auto exist_val_start = markers_list_start + var_len; 201 | 202 | bool is_align8 = false; 203 | int cnt = 5; 204 | long last_second_var_val = 0; 205 | for (auto y = markers_list_start + var_len; y + var_len < m_file_buf.size(); y += var_len * 2) { 206 | long val1 = *(long*)&m_file_buf[y]; 207 | long val2 = *(long*)&m_file_buf[y + var_len]; 208 | if (val2 != last_second_var_val) { 209 | break; 210 | } 211 | last_second_var_val = val2; 212 | cnt--; 213 | if (cnt == 0) { 214 | is_align8 = true; 215 | break; 216 | } 217 | } 218 | if (is_align8) { 219 | size_t back_val = align8(markers_list_start) - markers_list_start; 220 | if (back_val == 0) { 221 | markers_list_start -= 8; 222 | } else { 223 | markers_list_start -= back_val; // 4 224 | } 225 | markers_list_end = markers_list_start + ((kallsyms_num + 255) >> 8) * sizeof(long) * 2; 226 | } else { 227 | markers_list_end = markers_list_start + ((kallsyms_num + 255) >> 8) * sizeof(long); 228 | } 229 | 230 | return true; 231 | } 232 | 233 | bool KallsymsLookupName_4_6_0::find_kallsyms_token_table(size_t markers_list_end_offset, size_t& kallsyms_token_table_start, size_t& kallsyms_token_table_end) { 234 | size_t start = align8(markers_list_end_offset); 235 | const int var_len = sizeof(long); 236 | for (auto x = start; x + var_len < m_file_buf.size(); x += var_len) { 237 | long val1 = *(long*)&m_file_buf[x]; 238 | if (val1 == 0) { 239 | continue; 240 | } 241 | size_t off = x; 242 | for (unsigned int i = 0; i < 256; i++) { 243 | const char* str = (const char*)&m_file_buf[off]; 244 | off += strlen(str) + 1; 245 | } 246 | kallsyms_token_table_start = x; 247 | kallsyms_token_table_end = off; 248 | return true; 249 | } 250 | return false; 251 | } 252 | 253 | bool KallsymsLookupName_4_6_0::find_kallsyms_token_index(size_t kallsyms_token_table_end, size_t& kallsyms_token_index_start) { 254 | size_t start = align8(kallsyms_token_table_end); 255 | const int var_len = sizeof(short); 256 | for (auto x = start; x + var_len < m_file_buf.size(); x += var_len) { 257 | short val1 = *(short*)&m_file_buf[x]; 258 | short val2 = *(short*)&m_file_buf[x + var_len]; 259 | if (val1 == 0 && val2 > 0) { 260 | kallsyms_token_index_start = x; 261 | break; 262 | } 263 | else if (val1 == 0 && val2 == 0) { 264 | continue; 265 | } 266 | return false; 267 | } 268 | return true; 269 | } 270 | 271 | bool KallsymsLookupName_4_6_0::find_kallsyms_sym_func_entry_offset(size_t& kallsyms_sym_func_entry_offset) { 272 | size_t _text_offset = __kallsyms_lookup_name("_text"); 273 | size_t _stext_offset = __kallsyms_lookup_name("_stext"); 274 | if (_text_offset != 0) { 275 | return false; 276 | } 277 | const int var_len = sizeof(int); 278 | for (auto x = _stext_offset; x + var_len < m_file_buf.size(); x += var_len) { 279 | int val1 = *(int*)&m_file_buf[x]; 280 | if (val1 == 0 ) { 281 | continue; 282 | } 283 | kallsyms_sym_func_entry_offset = x - _stext_offset; 284 | break; 285 | } 286 | return true; 287 | } 288 | 289 | /* 290 | * Expand a compressed symbol data into the resulting uncompressed string, 291 | * if uncompressed string is too long (>= maxlen), it will be truncated, 292 | * given the offset to where the symbol is in the compressed stream. 293 | */ 294 | unsigned int KallsymsLookupName_4_6_0::kallsyms_expand_symbol(unsigned int off, char* result, size_t maxlen) 295 | { 296 | int len, skipped_first = 0; 297 | const char* tptr; 298 | const uint8_t* data; 299 | 300 | /* Get the compressed symbol length from the first symbol byte. */ 301 | 302 | data = (uint8_t*)&m_file_buf[m_kallsyms_names.offset + off * sizeof(uint8_t)]; 303 | 304 | len = *data; 305 | data++; 306 | 307 | /* 308 | * Update the offset to return the offset for the next symbol on 309 | * the compressed stream. 310 | */ 311 | off += len + 1; 312 | 313 | /* 314 | * For every byte on the compressed symbol data, copy the table 315 | * entry for that byte. 316 | */ 317 | 318 | while (len) { 319 | uint8_t x = *data; 320 | short y = *(short*)&m_file_buf[m_kallsyms_token_index.offset + x * sizeof(uint16_t)]; 321 | 322 | tptr = &m_file_buf[m_kallsyms_token_table.offset + y * sizeof(unsigned char)]; 323 | data++; 324 | len--; 325 | 326 | while (*tptr) { 327 | if (skipped_first) { 328 | if (maxlen <= 1) 329 | goto tail; 330 | *result = *tptr; 331 | result++; 332 | maxlen--; 333 | } 334 | else 335 | skipped_first = 1; 336 | tptr++; 337 | } 338 | } 339 | 340 | tail: 341 | if (maxlen) 342 | *result = '\0'; 343 | 344 | /* Return to offset to the next symbol. */ 345 | return off; 346 | } 347 | 348 | /* Lookup the address for this symbol. Returns 0 if not found. */ 349 | uint64_t KallsymsLookupName_4_6_0::__kallsyms_lookup_name(const char* name, bool include_str_mode) { 350 | for (auto i = 0, off = 0; i < m_kallsyms_num; i++) { 351 | char namebuf[KSYM_NAME_LEN] = { 0 }; 352 | off = kallsyms_expand_symbol(off, namebuf, sizeof(namebuf)); 353 | 354 | //std::cout << namebuf << std::endl; 355 | if (strcmp(namebuf, name) == 0 || (include_str_mode && strstr(namebuf, name))) { 356 | auto pos = m_kallsyms_offsets.offset + i * sizeof(int); 357 | uint64_t offset = *(long*)&m_file_buf[pos]; 358 | offset += m_kallsyms_sym_func_entry_offset; 359 | return offset; 360 | } 361 | } 362 | return 0; 363 | } 364 | 365 | uint64_t KallsymsLookupName_4_6_0::kallsyms_lookup_name(const char* name, bool include_str_mode) { 366 | if (!m_inited) { return 0; } 367 | return __kallsyms_lookup_name(name, include_str_mode); 368 | } 369 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/include/capstone/sparc.h: -------------------------------------------------------------------------------- 1 | #ifndef CAPSTONE_SPARC_H 2 | #define CAPSTONE_SPARC_H 3 | 4 | /* Capstone Disassembly Engine */ 5 | /* By Nguyen Anh Quynh , 2014-2015 */ 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | #include "platform.h" 12 | 13 | // GCC SPARC toolchain has a default macro called "sparc" which breaks 14 | // compilation 15 | #undef sparc 16 | 17 | #ifdef _MSC_VER 18 | #pragma warning(disable:4201) 19 | #endif 20 | 21 | /// Enums corresponding to Sparc condition codes, both icc's and fcc's. 22 | typedef enum sparc_cc { 23 | SPARC_CC_INVALID = 0, ///< invalid CC (default) 24 | // Integer condition codes 25 | SPARC_CC_ICC_A = 8+256, ///< Always 26 | SPARC_CC_ICC_N = 0+256, ///< Never 27 | SPARC_CC_ICC_NE = 9+256, ///< Not Equal 28 | SPARC_CC_ICC_E = 1+256, ///< Equal 29 | SPARC_CC_ICC_G = 10+256, ///< Greater 30 | SPARC_CC_ICC_LE = 2+256, ///< Less or Equal 31 | SPARC_CC_ICC_GE = 11+256, ///< Greater or Equal 32 | SPARC_CC_ICC_L = 3+256, ///< Less 33 | SPARC_CC_ICC_GU = 12+256, ///< Greater Unsigned 34 | SPARC_CC_ICC_LEU = 4+256, ///< Less or Equal Unsigned 35 | SPARC_CC_ICC_CC = 13+256, ///< Carry Clear/Great or Equal Unsigned 36 | SPARC_CC_ICC_CS = 5+256, ///< Carry Set/Less Unsigned 37 | SPARC_CC_ICC_POS = 14+256, ///< Positive 38 | SPARC_CC_ICC_NEG = 6+256, ///< Negative 39 | SPARC_CC_ICC_VC = 15+256, ///< Overflow Clear 40 | SPARC_CC_ICC_VS = 7+256, ///< Overflow Set 41 | 42 | // Floating condition codes 43 | SPARC_CC_FCC_A = 8+16+256, ///< Always 44 | SPARC_CC_FCC_N = 0+16+256, ///< Never 45 | SPARC_CC_FCC_U = 7+16+256, ///< Unordered 46 | SPARC_CC_FCC_G = 6+16+256, ///< Greater 47 | SPARC_CC_FCC_UG = 5+16+256, ///< Unordered or Greater 48 | SPARC_CC_FCC_L = 4+16+256, ///< Less 49 | SPARC_CC_FCC_UL = 3+16+256, ///< Unordered or Less 50 | SPARC_CC_FCC_LG = 2+16+256, ///< Less or Greater 51 | SPARC_CC_FCC_NE = 1+16+256, ///< Not Equal 52 | SPARC_CC_FCC_E = 9+16+256, ///< Equal 53 | SPARC_CC_FCC_UE = 10+16+256, ///< Unordered or Equal 54 | SPARC_CC_FCC_GE = 11+16+256, ///< Greater or Equal 55 | SPARC_CC_FCC_UGE = 12+16+256, ///< Unordered or Greater or Equal 56 | SPARC_CC_FCC_LE = 13+16+256, ///< Less or Equal 57 | SPARC_CC_FCC_ULE = 14+16+256, ///< Unordered or Less or Equal 58 | SPARC_CC_FCC_O = 15+16+256, ///< Ordered 59 | } sparc_cc; 60 | 61 | /// Branch hint 62 | typedef enum sparc_hint { 63 | SPARC_HINT_INVALID = 0, ///< no hint 64 | SPARC_HINT_A = 1 << 0, ///< annul delay slot instruction 65 | SPARC_HINT_PT = 1 << 1, ///< branch taken 66 | SPARC_HINT_PN = 1 << 2, ///< branch NOT taken 67 | } sparc_hint; 68 | 69 | /// Operand type for instruction's operands 70 | typedef enum sparc_op_type { 71 | SPARC_OP_INVALID = 0, ///< = CS_OP_INVALID (Uninitialized). 72 | SPARC_OP_REG, ///< = CS_OP_REG (Register operand). 73 | SPARC_OP_IMM, ///< = CS_OP_IMM (Immediate operand). 74 | SPARC_OP_MEM, ///< = CS_OP_MEM (Memory operand). 75 | } sparc_op_type; 76 | 77 | /// SPARC registers 78 | typedef enum sparc_reg { 79 | SPARC_REG_INVALID = 0, 80 | 81 | SPARC_REG_F0, 82 | SPARC_REG_F1, 83 | SPARC_REG_F2, 84 | SPARC_REG_F3, 85 | SPARC_REG_F4, 86 | SPARC_REG_F5, 87 | SPARC_REG_F6, 88 | SPARC_REG_F7, 89 | SPARC_REG_F8, 90 | SPARC_REG_F9, 91 | SPARC_REG_F10, 92 | SPARC_REG_F11, 93 | SPARC_REG_F12, 94 | SPARC_REG_F13, 95 | SPARC_REG_F14, 96 | SPARC_REG_F15, 97 | SPARC_REG_F16, 98 | SPARC_REG_F17, 99 | SPARC_REG_F18, 100 | SPARC_REG_F19, 101 | SPARC_REG_F20, 102 | SPARC_REG_F21, 103 | SPARC_REG_F22, 104 | SPARC_REG_F23, 105 | SPARC_REG_F24, 106 | SPARC_REG_F25, 107 | SPARC_REG_F26, 108 | SPARC_REG_F27, 109 | SPARC_REG_F28, 110 | SPARC_REG_F29, 111 | SPARC_REG_F30, 112 | SPARC_REG_F31, 113 | SPARC_REG_F32, 114 | SPARC_REG_F34, 115 | SPARC_REG_F36, 116 | SPARC_REG_F38, 117 | SPARC_REG_F40, 118 | SPARC_REG_F42, 119 | SPARC_REG_F44, 120 | SPARC_REG_F46, 121 | SPARC_REG_F48, 122 | SPARC_REG_F50, 123 | SPARC_REG_F52, 124 | SPARC_REG_F54, 125 | SPARC_REG_F56, 126 | SPARC_REG_F58, 127 | SPARC_REG_F60, 128 | SPARC_REG_F62, 129 | SPARC_REG_FCC0, // Floating condition codes 130 | SPARC_REG_FCC1, 131 | SPARC_REG_FCC2, 132 | SPARC_REG_FCC3, 133 | SPARC_REG_FP, 134 | SPARC_REG_G0, 135 | SPARC_REG_G1, 136 | SPARC_REG_G2, 137 | SPARC_REG_G3, 138 | SPARC_REG_G4, 139 | SPARC_REG_G5, 140 | SPARC_REG_G6, 141 | SPARC_REG_G7, 142 | SPARC_REG_I0, 143 | SPARC_REG_I1, 144 | SPARC_REG_I2, 145 | SPARC_REG_I3, 146 | SPARC_REG_I4, 147 | SPARC_REG_I5, 148 | SPARC_REG_I7, 149 | SPARC_REG_ICC, // Integer condition codes 150 | SPARC_REG_L0, 151 | SPARC_REG_L1, 152 | SPARC_REG_L2, 153 | SPARC_REG_L3, 154 | SPARC_REG_L4, 155 | SPARC_REG_L5, 156 | SPARC_REG_L6, 157 | SPARC_REG_L7, 158 | SPARC_REG_O0, 159 | SPARC_REG_O1, 160 | SPARC_REG_O2, 161 | SPARC_REG_O3, 162 | SPARC_REG_O4, 163 | SPARC_REG_O5, 164 | SPARC_REG_O7, 165 | SPARC_REG_SP, 166 | SPARC_REG_Y, 167 | 168 | // special register 169 | SPARC_REG_XCC, 170 | 171 | SPARC_REG_ENDING, // <-- mark the end of the list of registers 172 | 173 | // extras 174 | SPARC_REG_O6 = SPARC_REG_SP, 175 | SPARC_REG_I6 = SPARC_REG_FP, 176 | } sparc_reg; 177 | 178 | /// Instruction's operand referring to memory 179 | /// This is associated with SPARC_OP_MEM operand type above 180 | typedef struct sparc_op_mem { 181 | uint8_t base; ///< base register, can be safely interpreted as 182 | ///< a value of type `sparc_reg`, but it is only 183 | ///< one byte wide 184 | uint8_t index; ///< index register, same conditions apply here 185 | int32_t disp; ///< displacement/offset value 186 | } sparc_op_mem; 187 | 188 | /// Instruction operand 189 | typedef struct cs_sparc_op { 190 | sparc_op_type type; ///< operand type 191 | union { 192 | sparc_reg reg; ///< register value for REG operand 193 | int64_t imm; ///< immediate value for IMM operand 194 | sparc_op_mem mem; ///< base/disp value for MEM operand 195 | }; 196 | } cs_sparc_op; 197 | 198 | /// Instruction structure 199 | typedef struct cs_sparc { 200 | sparc_cc cc; ///< code condition for this insn 201 | sparc_hint hint; ///< branch hint: encoding as bitwise OR of sparc_hint. 202 | /// Number of operands of this instruction, 203 | /// or 0 when instruction has no operand. 204 | uint8_t op_count; 205 | cs_sparc_op operands[4]; ///< operands for this instruction. 206 | } cs_sparc; 207 | 208 | /// SPARC instruction 209 | typedef enum sparc_insn { 210 | SPARC_INS_INVALID = 0, 211 | 212 | SPARC_INS_ADDCC, 213 | SPARC_INS_ADDX, 214 | SPARC_INS_ADDXCC, 215 | SPARC_INS_ADDXC, 216 | SPARC_INS_ADDXCCC, 217 | SPARC_INS_ADD, 218 | SPARC_INS_ALIGNADDR, 219 | SPARC_INS_ALIGNADDRL, 220 | SPARC_INS_ANDCC, 221 | SPARC_INS_ANDNCC, 222 | SPARC_INS_ANDN, 223 | SPARC_INS_AND, 224 | SPARC_INS_ARRAY16, 225 | SPARC_INS_ARRAY32, 226 | SPARC_INS_ARRAY8, 227 | SPARC_INS_B, 228 | SPARC_INS_JMP, 229 | SPARC_INS_BMASK, 230 | SPARC_INS_FB, 231 | SPARC_INS_BRGEZ, 232 | SPARC_INS_BRGZ, 233 | SPARC_INS_BRLEZ, 234 | SPARC_INS_BRLZ, 235 | SPARC_INS_BRNZ, 236 | SPARC_INS_BRZ, 237 | SPARC_INS_BSHUFFLE, 238 | SPARC_INS_CALL, 239 | SPARC_INS_CASX, 240 | SPARC_INS_CAS, 241 | SPARC_INS_CMASK16, 242 | SPARC_INS_CMASK32, 243 | SPARC_INS_CMASK8, 244 | SPARC_INS_CMP, 245 | SPARC_INS_EDGE16, 246 | SPARC_INS_EDGE16L, 247 | SPARC_INS_EDGE16LN, 248 | SPARC_INS_EDGE16N, 249 | SPARC_INS_EDGE32, 250 | SPARC_INS_EDGE32L, 251 | SPARC_INS_EDGE32LN, 252 | SPARC_INS_EDGE32N, 253 | SPARC_INS_EDGE8, 254 | SPARC_INS_EDGE8L, 255 | SPARC_INS_EDGE8LN, 256 | SPARC_INS_EDGE8N, 257 | SPARC_INS_FABSD, 258 | SPARC_INS_FABSQ, 259 | SPARC_INS_FABSS, 260 | SPARC_INS_FADDD, 261 | SPARC_INS_FADDQ, 262 | SPARC_INS_FADDS, 263 | SPARC_INS_FALIGNDATA, 264 | SPARC_INS_FAND, 265 | SPARC_INS_FANDNOT1, 266 | SPARC_INS_FANDNOT1S, 267 | SPARC_INS_FANDNOT2, 268 | SPARC_INS_FANDNOT2S, 269 | SPARC_INS_FANDS, 270 | SPARC_INS_FCHKSM16, 271 | SPARC_INS_FCMPD, 272 | SPARC_INS_FCMPEQ16, 273 | SPARC_INS_FCMPEQ32, 274 | SPARC_INS_FCMPGT16, 275 | SPARC_INS_FCMPGT32, 276 | SPARC_INS_FCMPLE16, 277 | SPARC_INS_FCMPLE32, 278 | SPARC_INS_FCMPNE16, 279 | SPARC_INS_FCMPNE32, 280 | SPARC_INS_FCMPQ, 281 | SPARC_INS_FCMPS, 282 | SPARC_INS_FDIVD, 283 | SPARC_INS_FDIVQ, 284 | SPARC_INS_FDIVS, 285 | SPARC_INS_FDMULQ, 286 | SPARC_INS_FDTOI, 287 | SPARC_INS_FDTOQ, 288 | SPARC_INS_FDTOS, 289 | SPARC_INS_FDTOX, 290 | SPARC_INS_FEXPAND, 291 | SPARC_INS_FHADDD, 292 | SPARC_INS_FHADDS, 293 | SPARC_INS_FHSUBD, 294 | SPARC_INS_FHSUBS, 295 | SPARC_INS_FITOD, 296 | SPARC_INS_FITOQ, 297 | SPARC_INS_FITOS, 298 | SPARC_INS_FLCMPD, 299 | SPARC_INS_FLCMPS, 300 | SPARC_INS_FLUSHW, 301 | SPARC_INS_FMEAN16, 302 | SPARC_INS_FMOVD, 303 | SPARC_INS_FMOVQ, 304 | SPARC_INS_FMOVRDGEZ, 305 | SPARC_INS_FMOVRQGEZ, 306 | SPARC_INS_FMOVRSGEZ, 307 | SPARC_INS_FMOVRDGZ, 308 | SPARC_INS_FMOVRQGZ, 309 | SPARC_INS_FMOVRSGZ, 310 | SPARC_INS_FMOVRDLEZ, 311 | SPARC_INS_FMOVRQLEZ, 312 | SPARC_INS_FMOVRSLEZ, 313 | SPARC_INS_FMOVRDLZ, 314 | SPARC_INS_FMOVRQLZ, 315 | SPARC_INS_FMOVRSLZ, 316 | SPARC_INS_FMOVRDNZ, 317 | SPARC_INS_FMOVRQNZ, 318 | SPARC_INS_FMOVRSNZ, 319 | SPARC_INS_FMOVRDZ, 320 | SPARC_INS_FMOVRQZ, 321 | SPARC_INS_FMOVRSZ, 322 | SPARC_INS_FMOVS, 323 | SPARC_INS_FMUL8SUX16, 324 | SPARC_INS_FMUL8ULX16, 325 | SPARC_INS_FMUL8X16, 326 | SPARC_INS_FMUL8X16AL, 327 | SPARC_INS_FMUL8X16AU, 328 | SPARC_INS_FMULD, 329 | SPARC_INS_FMULD8SUX16, 330 | SPARC_INS_FMULD8ULX16, 331 | SPARC_INS_FMULQ, 332 | SPARC_INS_FMULS, 333 | SPARC_INS_FNADDD, 334 | SPARC_INS_FNADDS, 335 | SPARC_INS_FNAND, 336 | SPARC_INS_FNANDS, 337 | SPARC_INS_FNEGD, 338 | SPARC_INS_FNEGQ, 339 | SPARC_INS_FNEGS, 340 | SPARC_INS_FNHADDD, 341 | SPARC_INS_FNHADDS, 342 | SPARC_INS_FNOR, 343 | SPARC_INS_FNORS, 344 | SPARC_INS_FNOT1, 345 | SPARC_INS_FNOT1S, 346 | SPARC_INS_FNOT2, 347 | SPARC_INS_FNOT2S, 348 | SPARC_INS_FONE, 349 | SPARC_INS_FONES, 350 | SPARC_INS_FOR, 351 | SPARC_INS_FORNOT1, 352 | SPARC_INS_FORNOT1S, 353 | SPARC_INS_FORNOT2, 354 | SPARC_INS_FORNOT2S, 355 | SPARC_INS_FORS, 356 | SPARC_INS_FPACK16, 357 | SPARC_INS_FPACK32, 358 | SPARC_INS_FPACKFIX, 359 | SPARC_INS_FPADD16, 360 | SPARC_INS_FPADD16S, 361 | SPARC_INS_FPADD32, 362 | SPARC_INS_FPADD32S, 363 | SPARC_INS_FPADD64, 364 | SPARC_INS_FPMERGE, 365 | SPARC_INS_FPSUB16, 366 | SPARC_INS_FPSUB16S, 367 | SPARC_INS_FPSUB32, 368 | SPARC_INS_FPSUB32S, 369 | SPARC_INS_FQTOD, 370 | SPARC_INS_FQTOI, 371 | SPARC_INS_FQTOS, 372 | SPARC_INS_FQTOX, 373 | SPARC_INS_FSLAS16, 374 | SPARC_INS_FSLAS32, 375 | SPARC_INS_FSLL16, 376 | SPARC_INS_FSLL32, 377 | SPARC_INS_FSMULD, 378 | SPARC_INS_FSQRTD, 379 | SPARC_INS_FSQRTQ, 380 | SPARC_INS_FSQRTS, 381 | SPARC_INS_FSRA16, 382 | SPARC_INS_FSRA32, 383 | SPARC_INS_FSRC1, 384 | SPARC_INS_FSRC1S, 385 | SPARC_INS_FSRC2, 386 | SPARC_INS_FSRC2S, 387 | SPARC_INS_FSRL16, 388 | SPARC_INS_FSRL32, 389 | SPARC_INS_FSTOD, 390 | SPARC_INS_FSTOI, 391 | SPARC_INS_FSTOQ, 392 | SPARC_INS_FSTOX, 393 | SPARC_INS_FSUBD, 394 | SPARC_INS_FSUBQ, 395 | SPARC_INS_FSUBS, 396 | SPARC_INS_FXNOR, 397 | SPARC_INS_FXNORS, 398 | SPARC_INS_FXOR, 399 | SPARC_INS_FXORS, 400 | SPARC_INS_FXTOD, 401 | SPARC_INS_FXTOQ, 402 | SPARC_INS_FXTOS, 403 | SPARC_INS_FZERO, 404 | SPARC_INS_FZEROS, 405 | SPARC_INS_JMPL, 406 | SPARC_INS_LDD, 407 | SPARC_INS_LD, 408 | SPARC_INS_LDQ, 409 | SPARC_INS_LDSB, 410 | SPARC_INS_LDSH, 411 | SPARC_INS_LDSW, 412 | SPARC_INS_LDUB, 413 | SPARC_INS_LDUH, 414 | SPARC_INS_LDX, 415 | SPARC_INS_LZCNT, 416 | SPARC_INS_MEMBAR, 417 | SPARC_INS_MOVDTOX, 418 | SPARC_INS_MOV, 419 | SPARC_INS_MOVRGEZ, 420 | SPARC_INS_MOVRGZ, 421 | SPARC_INS_MOVRLEZ, 422 | SPARC_INS_MOVRLZ, 423 | SPARC_INS_MOVRNZ, 424 | SPARC_INS_MOVRZ, 425 | SPARC_INS_MOVSTOSW, 426 | SPARC_INS_MOVSTOUW, 427 | SPARC_INS_MULX, 428 | SPARC_INS_NOP, 429 | SPARC_INS_ORCC, 430 | SPARC_INS_ORNCC, 431 | SPARC_INS_ORN, 432 | SPARC_INS_OR, 433 | SPARC_INS_PDIST, 434 | SPARC_INS_PDISTN, 435 | SPARC_INS_POPC, 436 | SPARC_INS_RD, 437 | SPARC_INS_RESTORE, 438 | SPARC_INS_RETT, 439 | SPARC_INS_SAVE, 440 | SPARC_INS_SDIVCC, 441 | SPARC_INS_SDIVX, 442 | SPARC_INS_SDIV, 443 | SPARC_INS_SETHI, 444 | SPARC_INS_SHUTDOWN, 445 | SPARC_INS_SIAM, 446 | SPARC_INS_SLLX, 447 | SPARC_INS_SLL, 448 | SPARC_INS_SMULCC, 449 | SPARC_INS_SMUL, 450 | SPARC_INS_SRAX, 451 | SPARC_INS_SRA, 452 | SPARC_INS_SRLX, 453 | SPARC_INS_SRL, 454 | SPARC_INS_STBAR, 455 | SPARC_INS_STB, 456 | SPARC_INS_STD, 457 | SPARC_INS_ST, 458 | SPARC_INS_STH, 459 | SPARC_INS_STQ, 460 | SPARC_INS_STX, 461 | SPARC_INS_SUBCC, 462 | SPARC_INS_SUBX, 463 | SPARC_INS_SUBXCC, 464 | SPARC_INS_SUB, 465 | SPARC_INS_SWAP, 466 | SPARC_INS_TADDCCTV, 467 | SPARC_INS_TADDCC, 468 | SPARC_INS_T, 469 | SPARC_INS_TSUBCCTV, 470 | SPARC_INS_TSUBCC, 471 | SPARC_INS_UDIVCC, 472 | SPARC_INS_UDIVX, 473 | SPARC_INS_UDIV, 474 | SPARC_INS_UMULCC, 475 | SPARC_INS_UMULXHI, 476 | SPARC_INS_UMUL, 477 | SPARC_INS_UNIMP, 478 | SPARC_INS_FCMPED, 479 | SPARC_INS_FCMPEQ, 480 | SPARC_INS_FCMPES, 481 | SPARC_INS_WR, 482 | SPARC_INS_XMULX, 483 | SPARC_INS_XMULXHI, 484 | SPARC_INS_XNORCC, 485 | SPARC_INS_XNOR, 486 | SPARC_INS_XORCC, 487 | SPARC_INS_XOR, 488 | 489 | // alias instructions 490 | SPARC_INS_RET, 491 | SPARC_INS_RETL, 492 | 493 | SPARC_INS_ENDING, // <-- mark the end of the list of instructions 494 | } sparc_insn; 495 | 496 | /// Group of SPARC instructions 497 | typedef enum sparc_insn_group { 498 | SPARC_GRP_INVALID = 0, ///< = CS_GRP_INVALID 499 | 500 | // Generic groups 501 | // all jump instructions (conditional+direct+indirect jumps) 502 | SPARC_GRP_JUMP, ///< = CS_GRP_JUMP 503 | 504 | // Architecture-specific groups 505 | SPARC_GRP_HARDQUAD = 128, 506 | SPARC_GRP_V9, 507 | SPARC_GRP_VIS, 508 | SPARC_GRP_VIS2, 509 | SPARC_GRP_VIS3, 510 | SPARC_GRP_32BIT, 511 | SPARC_GRP_64BIT, 512 | 513 | SPARC_GRP_ENDING, // <-- mark the end of the list of groups 514 | } sparc_insn_group; 515 | 516 | #ifdef __cplusplus 517 | } 518 | #endif 519 | 520 | #endif 521 | -------------------------------------------------------------------------------- /patch_kernel_root/3rdparty/capstone-4.0.2-win64/include/capstone/m680x.h: -------------------------------------------------------------------------------- 1 | #ifndef CAPSTONE_M680X_H 2 | #define CAPSTONE_M680X_H 3 | 4 | /* Capstone Disassembly Engine */ 5 | /* M680X Backend by Wolfgang Schwotzer 2017 */ 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | #include "platform.h" 12 | 13 | #ifdef _MSC_VER 14 | #pragma warning(disable:4201) 15 | #endif 16 | 17 | #define M680X_OPERAND_COUNT 9 18 | 19 | /// M680X registers and special registers 20 | typedef enum m680x_reg { 21 | M680X_REG_INVALID = 0, 22 | 23 | M680X_REG_A, ///< M6800/1/2/3/9, HD6301/9 24 | M680X_REG_B, ///< M6800/1/2/3/9, HD6301/9 25 | M680X_REG_E, ///< HD6309 26 | M680X_REG_F, ///< HD6309 27 | M680X_REG_0, ///< HD6309 28 | 29 | M680X_REG_D, ///< M6801/3/9, HD6301/9 30 | M680X_REG_W, ///< HD6309 31 | 32 | M680X_REG_CC, ///< M6800/1/2/3/9, M6301/9 33 | M680X_REG_DP, ///< M6809/M6309 34 | M680X_REG_MD, ///< M6309 35 | 36 | M680X_REG_HX, ///< M6808 37 | M680X_REG_H, ///< M6808 38 | M680X_REG_X, ///< M6800/1/2/3/9, M6301/9 39 | M680X_REG_Y, ///< M6809/M6309 40 | M680X_REG_S, ///< M6809/M6309 41 | M680X_REG_U, ///< M6809/M6309 42 | M680X_REG_V, ///< M6309 43 | 44 | M680X_REG_Q, ///< M6309 45 | 46 | M680X_REG_PC, ///< M6800/1/2/3/9, M6301/9 47 | 48 | M680X_REG_TMP2, ///< CPU12 49 | M680X_REG_TMP3, ///< CPU12 50 | 51 | M680X_REG_ENDING, ///< <-- mark the end of the list of registers 52 | } m680x_reg; 53 | 54 | /// Operand type for instruction's operands 55 | typedef enum m680x_op_type { 56 | M680X_OP_INVALID = 0, ///< = CS_OP_INVALID (Uninitialized). 57 | M680X_OP_REGISTER, ///< = Register operand. 58 | M680X_OP_IMMEDIATE, ///< = Immediate operand. 59 | M680X_OP_INDEXED, ///< = Indexed addressing operand. 60 | M680X_OP_EXTENDED, ///< = Extended addressing operand. 61 | M680X_OP_DIRECT, ///< = Direct addressing operand. 62 | M680X_OP_RELATIVE, ///< = Relative addressing operand. 63 | M680X_OP_CONSTANT, ///< = constant operand (Displayed as number only). 64 | ///< Used e.g. for a bit index or page number. 65 | } m680x_op_type; 66 | 67 | // Supported bit values for mem.idx.offset_bits 68 | #define M680X_OFFSET_NONE 0 69 | #define M680X_OFFSET_BITS_5 5 70 | #define M680X_OFFSET_BITS_8 8 71 | #define M680X_OFFSET_BITS_9 9 72 | #define M680X_OFFSET_BITS_16 16 73 | 74 | // Supported bit flags for mem.idx.flags 75 | // These flags can be combined 76 | #define M680X_IDX_INDIRECT 1 77 | #define M680X_IDX_NO_COMMA 2 78 | #define M680X_IDX_POST_INC_DEC 4 79 | 80 | /// Instruction's operand referring to indexed addressing 81 | typedef struct m680x_op_idx { 82 | m680x_reg base_reg; ///< base register (or M680X_REG_INVALID if 83 | ///< irrelevant) 84 | m680x_reg offset_reg; ///< offset register (or M680X_REG_INVALID if 85 | ///< irrelevant) 86 | int16_t offset; ///< 5-,8- or 16-bit offset. See also offset_bits. 87 | uint16_t offset_addr; ///< = offset addr. if base_reg == M680X_REG_PC. 88 | ///< calculated as offset + PC 89 | uint8_t offset_bits; ///< offset width in bits for indexed addressing 90 | int8_t inc_dec; ///< inc. or dec. value: 91 | ///< 0: no inc-/decrement 92 | ///< 1 .. 8: increment by 1 .. 8 93 | ///< -1 .. -8: decrement by 1 .. 8 94 | ///< if flag M680X_IDX_POST_INC_DEC set it is post 95 | ///< inc-/decrement otherwise pre inc-/decrement 96 | uint8_t flags; ///< 8-bit flags (see above) 97 | } m680x_op_idx; 98 | 99 | /// Instruction's memory operand referring to relative addressing (Bcc/LBcc) 100 | typedef struct m680x_op_rel { 101 | uint16_t address; ///< The absolute address. 102 | ///< calculated as PC + offset. PC is the first 103 | ///< address after the instruction. 104 | int16_t offset; ///< the offset/displacement value 105 | } m680x_op_rel; 106 | 107 | /// Instruction's operand referring to extended addressing 108 | typedef struct m680x_op_ext { 109 | uint16_t address; ///< The absolute address 110 | bool indirect; ///< true if extended indirect addressing 111 | } m680x_op_ext; 112 | 113 | /// Instruction operand 114 | typedef struct cs_m680x_op { 115 | m680x_op_type type; 116 | union { 117 | int32_t imm; ///< immediate value for IMM operand 118 | m680x_reg reg; ///< register value for REG operand 119 | m680x_op_idx idx; ///< Indexed addressing operand 120 | m680x_op_rel rel; ///< Relative address. operand (Bcc/LBcc) 121 | m680x_op_ext ext; ///< Extended address 122 | uint8_t direct_addr; ///<, 2015-2016 */ 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | #include "platform.h" 12 | 13 | #ifdef _MSC_VER 14 | #pragma warning(disable:4201) 15 | #endif 16 | 17 | #define M68K_OPERAND_COUNT 4 18 | 19 | /// M68K registers and special registers 20 | typedef enum m68k_reg { 21 | M68K_REG_INVALID = 0, 22 | 23 | M68K_REG_D0, 24 | M68K_REG_D1, 25 | M68K_REG_D2, 26 | M68K_REG_D3, 27 | M68K_REG_D4, 28 | M68K_REG_D5, 29 | M68K_REG_D6, 30 | M68K_REG_D7, 31 | 32 | M68K_REG_A0, 33 | M68K_REG_A1, 34 | M68K_REG_A2, 35 | M68K_REG_A3, 36 | M68K_REG_A4, 37 | M68K_REG_A5, 38 | M68K_REG_A6, 39 | M68K_REG_A7, 40 | 41 | M68K_REG_FP0, 42 | M68K_REG_FP1, 43 | M68K_REG_FP2, 44 | M68K_REG_FP3, 45 | M68K_REG_FP4, 46 | M68K_REG_FP5, 47 | M68K_REG_FP6, 48 | M68K_REG_FP7, 49 | 50 | M68K_REG_PC, 51 | 52 | M68K_REG_SR, 53 | M68K_REG_CCR, 54 | M68K_REG_SFC, 55 | M68K_REG_DFC, 56 | M68K_REG_USP, 57 | M68K_REG_VBR, 58 | M68K_REG_CACR, 59 | M68K_REG_CAAR, 60 | M68K_REG_MSP, 61 | M68K_REG_ISP, 62 | M68K_REG_TC, 63 | M68K_REG_ITT0, 64 | M68K_REG_ITT1, 65 | M68K_REG_DTT0, 66 | M68K_REG_DTT1, 67 | M68K_REG_MMUSR, 68 | M68K_REG_URP, 69 | M68K_REG_SRP, 70 | 71 | M68K_REG_FPCR, 72 | M68K_REG_FPSR, 73 | M68K_REG_FPIAR, 74 | 75 | M68K_REG_ENDING, // <-- mark the end of the list of registers 76 | } m68k_reg; 77 | 78 | /// M68K Addressing Modes 79 | typedef enum m68k_address_mode { 80 | M68K_AM_NONE = 0, ///< No address mode. 81 | 82 | M68K_AM_REG_DIRECT_DATA, ///< Register Direct - Data 83 | M68K_AM_REG_DIRECT_ADDR, ///< Register Direct - Address 84 | 85 | M68K_AM_REGI_ADDR, ///< Register Indirect - Address 86 | M68K_AM_REGI_ADDR_POST_INC, ///< Register Indirect - Address with Postincrement 87 | M68K_AM_REGI_ADDR_PRE_DEC, ///< Register Indirect - Address with Predecrement 88 | M68K_AM_REGI_ADDR_DISP, ///< Register Indirect - Address with Displacement 89 | 90 | M68K_AM_AREGI_INDEX_8_BIT_DISP, ///< Address Register Indirect With Index- 8-bit displacement 91 | M68K_AM_AREGI_INDEX_BASE_DISP, ///< Address Register Indirect With Index- Base displacement 92 | 93 | M68K_AM_MEMI_POST_INDEX, ///< Memory indirect - Postindex 94 | M68K_AM_MEMI_PRE_INDEX, ///< Memory indirect - Preindex 95 | 96 | M68K_AM_PCI_DISP, ///< Program Counter Indirect - with Displacement 97 | 98 | M68K_AM_PCI_INDEX_8_BIT_DISP, ///< Program Counter Indirect with Index - with 8-Bit Displacement 99 | M68K_AM_PCI_INDEX_BASE_DISP, ///< Program Counter Indirect with Index - with Base Displacement 100 | 101 | M68K_AM_PC_MEMI_POST_INDEX, ///< Program Counter Memory Indirect - Postindexed 102 | M68K_AM_PC_MEMI_PRE_INDEX, ///< Program Counter Memory Indirect - Preindexed 103 | 104 | M68K_AM_ABSOLUTE_DATA_SHORT, ///< Absolute Data Addressing - Short 105 | M68K_AM_ABSOLUTE_DATA_LONG, ///< Absolute Data Addressing - Long 106 | M68K_AM_IMMEDIATE, ///< Immediate value 107 | 108 | M68K_AM_BRANCH_DISPLACEMENT, ///< Address as displacement from (PC+2) used by branches 109 | } m68k_address_mode; 110 | 111 | /// Operand type for instruction's operands 112 | typedef enum m68k_op_type { 113 | M68K_OP_INVALID = 0, ///< = CS_OP_INVALID (Uninitialized). 114 | M68K_OP_REG, ///< = CS_OP_REG (Register operand). 115 | M68K_OP_IMM, ///< = CS_OP_IMM (Immediate operand). 116 | M68K_OP_MEM, ///< = CS_OP_MEM (Memory operand). 117 | M68K_OP_FP_SINGLE, ///< single precision Floating-Point operand 118 | M68K_OP_FP_DOUBLE, ///< double precision Floating-Point operand 119 | M68K_OP_REG_BITS, ///< Register bits move 120 | M68K_OP_REG_PAIR, ///< Register pair in the same op (upper 4 bits for first reg, lower for second) 121 | M68K_OP_BR_DISP, ///< Branch displacement 122 | } m68k_op_type; 123 | 124 | /// Instruction's operand referring to memory 125 | /// This is associated with M68K_OP_MEM operand type above 126 | typedef struct m68k_op_mem { 127 | m68k_reg base_reg; ///< base register (or M68K_REG_INVALID if irrelevant) 128 | m68k_reg index_reg; ///< index register (or M68K_REG_INVALID if irrelevant) 129 | m68k_reg in_base_reg; ///< indirect base register (or M68K_REG_INVALID if irrelevant) 130 | uint32_t in_disp; ///< indirect displacement 131 | uint32_t out_disp; ///< other displacement 132 | int16_t disp; ///< displacement value 133 | uint8_t scale; ///< scale for index register 134 | uint8_t bitfield; ///< set to true if the two values below should be used 135 | uint8_t width; ///< used for bf* instructions 136 | uint8_t offset; ///< used for bf* instructions 137 | uint8_t index_size; ///< 0 = w, 1 = l 138 | } m68k_op_mem; 139 | 140 | /// Operand type for instruction's operands 141 | typedef enum m68k_op_br_disp_size { 142 | M68K_OP_BR_DISP_SIZE_INVALID = 0, ///< = CS_OP_INVALID (Uninitialized). 143 | M68K_OP_BR_DISP_SIZE_BYTE = 1, ///< signed 8-bit displacement 144 | M68K_OP_BR_DISP_SIZE_WORD = 2, ///< signed 16-bit displacement 145 | M68K_OP_BR_DISP_SIZE_LONG = 4, ///< signed 32-bit displacement 146 | } m68k_op_br_disp_size; 147 | 148 | typedef struct m68k_op_br_disp { 149 | int32_t disp; ///< displacement value 150 | uint8_t disp_size; ///< Size from m68k_op_br_disp_size type above 151 | } m68k_op_br_disp; 152 | 153 | /// Register pair in one operand. 154 | typedef struct cs_m68k_op_reg_pair { 155 | m68k_reg reg_0; 156 | m68k_reg reg_1; 157 | } cs_m68k_op_reg_pair; 158 | 159 | /// Instruction operand 160 | typedef struct cs_m68k_op { 161 | union { 162 | uint64_t imm; ///< immediate value for IMM operand 163 | double dimm; ///< double imm 164 | float simm; ///< float imm 165 | m68k_reg reg; ///< register value for REG operand 166 | cs_m68k_op_reg_pair reg_pair; ///< register pair in one operand 167 | }; 168 | 169 | m68k_op_mem mem; ///< data when operand is targeting memory 170 | m68k_op_br_disp br_disp; ///< data when operand is a branch displacement 171 | uint32_t register_bits; ///< register bits for movem etc. (always in d0-d7, a0-a7, fp0 - fp7 order) 172 | m68k_op_type type; 173 | m68k_address_mode address_mode; ///< M68K addressing mode for this op 174 | } cs_m68k_op; 175 | 176 | /// Operation size of the CPU instructions 177 | typedef enum m68k_cpu_size { 178 | M68K_CPU_SIZE_NONE = 0, ///< unsized or unspecified 179 | M68K_CPU_SIZE_BYTE = 1, ///< 1 byte in size 180 | M68K_CPU_SIZE_WORD = 2, ///< 2 bytes in size 181 | M68K_CPU_SIZE_LONG = 4, ///< 4 bytes in size 182 | } m68k_cpu_size; 183 | 184 | /// Operation size of the FPU instructions (Notice that FPU instruction can also use CPU sizes if needed) 185 | typedef enum m68k_fpu_size { 186 | M68K_FPU_SIZE_NONE = 0, ///< unsized like fsave/frestore 187 | M68K_FPU_SIZE_SINGLE = 4, ///< 4 byte in size (single float) 188 | M68K_FPU_SIZE_DOUBLE = 8, ///< 8 byte in size (double) 189 | M68K_FPU_SIZE_EXTENDED = 12, ///< 12 byte in size (extended real format) 190 | } m68k_fpu_size; 191 | 192 | /// Type of size that is being used for the current instruction 193 | typedef enum m68k_size_type { 194 | M68K_SIZE_TYPE_INVALID = 0, 195 | 196 | M68K_SIZE_TYPE_CPU, 197 | M68K_SIZE_TYPE_FPU, 198 | } m68k_size_type; 199 | 200 | /// Operation size of the current instruction (NOT the actually size of instruction) 201 | typedef struct m68k_op_size { 202 | m68k_size_type type; 203 | union { 204 | m68k_cpu_size cpu_size; 205 | m68k_fpu_size fpu_size; 206 | }; 207 | } m68k_op_size; 208 | 209 | /// The M68K instruction and it's operands 210 | typedef struct cs_m68k { 211 | // Number of operands of this instruction or 0 when instruction has no operand. 212 | cs_m68k_op operands[M68K_OPERAND_COUNT]; ///< operands for this instruction. 213 | m68k_op_size op_size; ///< size of data operand works on in bytes (.b, .w, .l, etc) 214 | uint8_t op_count; ///< number of operands for the instruction 215 | } cs_m68k; 216 | 217 | /// M68K instruction 218 | typedef enum m68k_insn { 219 | M68K_INS_INVALID = 0, 220 | 221 | M68K_INS_ABCD, 222 | M68K_INS_ADD, 223 | M68K_INS_ADDA, 224 | M68K_INS_ADDI, 225 | M68K_INS_ADDQ, 226 | M68K_INS_ADDX, 227 | M68K_INS_AND, 228 | M68K_INS_ANDI, 229 | M68K_INS_ASL, 230 | M68K_INS_ASR, 231 | M68K_INS_BHS, 232 | M68K_INS_BLO, 233 | M68K_INS_BHI, 234 | M68K_INS_BLS, 235 | M68K_INS_BCC, 236 | M68K_INS_BCS, 237 | M68K_INS_BNE, 238 | M68K_INS_BEQ, 239 | M68K_INS_BVC, 240 | M68K_INS_BVS, 241 | M68K_INS_BPL, 242 | M68K_INS_BMI, 243 | M68K_INS_BGE, 244 | M68K_INS_BLT, 245 | M68K_INS_BGT, 246 | M68K_INS_BLE, 247 | M68K_INS_BRA, 248 | M68K_INS_BSR, 249 | M68K_INS_BCHG, 250 | M68K_INS_BCLR, 251 | M68K_INS_BSET, 252 | M68K_INS_BTST, 253 | M68K_INS_BFCHG, 254 | M68K_INS_BFCLR, 255 | M68K_INS_BFEXTS, 256 | M68K_INS_BFEXTU, 257 | M68K_INS_BFFFO, 258 | M68K_INS_BFINS, 259 | M68K_INS_BFSET, 260 | M68K_INS_BFTST, 261 | M68K_INS_BKPT, 262 | M68K_INS_CALLM, 263 | M68K_INS_CAS, 264 | M68K_INS_CAS2, 265 | M68K_INS_CHK, 266 | M68K_INS_CHK2, 267 | M68K_INS_CLR, 268 | M68K_INS_CMP, 269 | M68K_INS_CMPA, 270 | M68K_INS_CMPI, 271 | M68K_INS_CMPM, 272 | M68K_INS_CMP2, 273 | M68K_INS_CINVL, 274 | M68K_INS_CINVP, 275 | M68K_INS_CINVA, 276 | M68K_INS_CPUSHL, 277 | M68K_INS_CPUSHP, 278 | M68K_INS_CPUSHA, 279 | M68K_INS_DBT, 280 | M68K_INS_DBF, 281 | M68K_INS_DBHI, 282 | M68K_INS_DBLS, 283 | M68K_INS_DBCC, 284 | M68K_INS_DBCS, 285 | M68K_INS_DBNE, 286 | M68K_INS_DBEQ, 287 | M68K_INS_DBVC, 288 | M68K_INS_DBVS, 289 | M68K_INS_DBPL, 290 | M68K_INS_DBMI, 291 | M68K_INS_DBGE, 292 | M68K_INS_DBLT, 293 | M68K_INS_DBGT, 294 | M68K_INS_DBLE, 295 | M68K_INS_DBRA, 296 | M68K_INS_DIVS, 297 | M68K_INS_DIVSL, 298 | M68K_INS_DIVU, 299 | M68K_INS_DIVUL, 300 | M68K_INS_EOR, 301 | M68K_INS_EORI, 302 | M68K_INS_EXG, 303 | M68K_INS_EXT, 304 | M68K_INS_EXTB, 305 | M68K_INS_FABS, 306 | M68K_INS_FSABS, 307 | M68K_INS_FDABS, 308 | M68K_INS_FACOS, 309 | M68K_INS_FADD, 310 | M68K_INS_FSADD, 311 | M68K_INS_FDADD, 312 | M68K_INS_FASIN, 313 | M68K_INS_FATAN, 314 | M68K_INS_FATANH, 315 | M68K_INS_FBF, 316 | M68K_INS_FBEQ, 317 | M68K_INS_FBOGT, 318 | M68K_INS_FBOGE, 319 | M68K_INS_FBOLT, 320 | M68K_INS_FBOLE, 321 | M68K_INS_FBOGL, 322 | M68K_INS_FBOR, 323 | M68K_INS_FBUN, 324 | M68K_INS_FBUEQ, 325 | M68K_INS_FBUGT, 326 | M68K_INS_FBUGE, 327 | M68K_INS_FBULT, 328 | M68K_INS_FBULE, 329 | M68K_INS_FBNE, 330 | M68K_INS_FBT, 331 | M68K_INS_FBSF, 332 | M68K_INS_FBSEQ, 333 | M68K_INS_FBGT, 334 | M68K_INS_FBGE, 335 | M68K_INS_FBLT, 336 | M68K_INS_FBLE, 337 | M68K_INS_FBGL, 338 | M68K_INS_FBGLE, 339 | M68K_INS_FBNGLE, 340 | M68K_INS_FBNGL, 341 | M68K_INS_FBNLE, 342 | M68K_INS_FBNLT, 343 | M68K_INS_FBNGE, 344 | M68K_INS_FBNGT, 345 | M68K_INS_FBSNE, 346 | M68K_INS_FBST, 347 | M68K_INS_FCMP, 348 | M68K_INS_FCOS, 349 | M68K_INS_FCOSH, 350 | M68K_INS_FDBF, 351 | M68K_INS_FDBEQ, 352 | M68K_INS_FDBOGT, 353 | M68K_INS_FDBOGE, 354 | M68K_INS_FDBOLT, 355 | M68K_INS_FDBOLE, 356 | M68K_INS_FDBOGL, 357 | M68K_INS_FDBOR, 358 | M68K_INS_FDBUN, 359 | M68K_INS_FDBUEQ, 360 | M68K_INS_FDBUGT, 361 | M68K_INS_FDBUGE, 362 | M68K_INS_FDBULT, 363 | M68K_INS_FDBULE, 364 | M68K_INS_FDBNE, 365 | M68K_INS_FDBT, 366 | M68K_INS_FDBSF, 367 | M68K_INS_FDBSEQ, 368 | M68K_INS_FDBGT, 369 | M68K_INS_FDBGE, 370 | M68K_INS_FDBLT, 371 | M68K_INS_FDBLE, 372 | M68K_INS_FDBGL, 373 | M68K_INS_FDBGLE, 374 | M68K_INS_FDBNGLE, 375 | M68K_INS_FDBNGL, 376 | M68K_INS_FDBNLE, 377 | M68K_INS_FDBNLT, 378 | M68K_INS_FDBNGE, 379 | M68K_INS_FDBNGT, 380 | M68K_INS_FDBSNE, 381 | M68K_INS_FDBST, 382 | M68K_INS_FDIV, 383 | M68K_INS_FSDIV, 384 | M68K_INS_FDDIV, 385 | M68K_INS_FETOX, 386 | M68K_INS_FETOXM1, 387 | M68K_INS_FGETEXP, 388 | M68K_INS_FGETMAN, 389 | M68K_INS_FINT, 390 | M68K_INS_FINTRZ, 391 | M68K_INS_FLOG10, 392 | M68K_INS_FLOG2, 393 | M68K_INS_FLOGN, 394 | M68K_INS_FLOGNP1, 395 | M68K_INS_FMOD, 396 | M68K_INS_FMOVE, 397 | M68K_INS_FSMOVE, 398 | M68K_INS_FDMOVE, 399 | M68K_INS_FMOVECR, 400 | M68K_INS_FMOVEM, 401 | M68K_INS_FMUL, 402 | M68K_INS_FSMUL, 403 | M68K_INS_FDMUL, 404 | M68K_INS_FNEG, 405 | M68K_INS_FSNEG, 406 | M68K_INS_FDNEG, 407 | M68K_INS_FNOP, 408 | M68K_INS_FREM, 409 | M68K_INS_FRESTORE, 410 | M68K_INS_FSAVE, 411 | M68K_INS_FSCALE, 412 | M68K_INS_FSGLDIV, 413 | M68K_INS_FSGLMUL, 414 | M68K_INS_FSIN, 415 | M68K_INS_FSINCOS, 416 | M68K_INS_FSINH, 417 | M68K_INS_FSQRT, 418 | M68K_INS_FSSQRT, 419 | M68K_INS_FDSQRT, 420 | M68K_INS_FSF, 421 | M68K_INS_FSBEQ, 422 | M68K_INS_FSOGT, 423 | M68K_INS_FSOGE, 424 | M68K_INS_FSOLT, 425 | M68K_INS_FSOLE, 426 | M68K_INS_FSOGL, 427 | M68K_INS_FSOR, 428 | M68K_INS_FSUN, 429 | M68K_INS_FSUEQ, 430 | M68K_INS_FSUGT, 431 | M68K_INS_FSUGE, 432 | M68K_INS_FSULT, 433 | M68K_INS_FSULE, 434 | M68K_INS_FSNE, 435 | M68K_INS_FST, 436 | M68K_INS_FSSF, 437 | M68K_INS_FSSEQ, 438 | M68K_INS_FSGT, 439 | M68K_INS_FSGE, 440 | M68K_INS_FSLT, 441 | M68K_INS_FSLE, 442 | M68K_INS_FSGL, 443 | M68K_INS_FSGLE, 444 | M68K_INS_FSNGLE, 445 | M68K_INS_FSNGL, 446 | M68K_INS_FSNLE, 447 | M68K_INS_FSNLT, 448 | M68K_INS_FSNGE, 449 | M68K_INS_FSNGT, 450 | M68K_INS_FSSNE, 451 | M68K_INS_FSST, 452 | M68K_INS_FSUB, 453 | M68K_INS_FSSUB, 454 | M68K_INS_FDSUB, 455 | M68K_INS_FTAN, 456 | M68K_INS_FTANH, 457 | M68K_INS_FTENTOX, 458 | M68K_INS_FTRAPF, 459 | M68K_INS_FTRAPEQ, 460 | M68K_INS_FTRAPOGT, 461 | M68K_INS_FTRAPOGE, 462 | M68K_INS_FTRAPOLT, 463 | M68K_INS_FTRAPOLE, 464 | M68K_INS_FTRAPOGL, 465 | M68K_INS_FTRAPOR, 466 | M68K_INS_FTRAPUN, 467 | M68K_INS_FTRAPUEQ, 468 | M68K_INS_FTRAPUGT, 469 | M68K_INS_FTRAPUGE, 470 | M68K_INS_FTRAPULT, 471 | M68K_INS_FTRAPULE, 472 | M68K_INS_FTRAPNE, 473 | M68K_INS_FTRAPT, 474 | M68K_INS_FTRAPSF, 475 | M68K_INS_FTRAPSEQ, 476 | M68K_INS_FTRAPGT, 477 | M68K_INS_FTRAPGE, 478 | M68K_INS_FTRAPLT, 479 | M68K_INS_FTRAPLE, 480 | M68K_INS_FTRAPGL, 481 | M68K_INS_FTRAPGLE, 482 | M68K_INS_FTRAPNGLE, 483 | M68K_INS_FTRAPNGL, 484 | M68K_INS_FTRAPNLE, 485 | M68K_INS_FTRAPNLT, 486 | M68K_INS_FTRAPNGE, 487 | M68K_INS_FTRAPNGT, 488 | M68K_INS_FTRAPSNE, 489 | M68K_INS_FTRAPST, 490 | M68K_INS_FTST, 491 | M68K_INS_FTWOTOX, 492 | M68K_INS_HALT, 493 | M68K_INS_ILLEGAL, 494 | M68K_INS_JMP, 495 | M68K_INS_JSR, 496 | M68K_INS_LEA, 497 | M68K_INS_LINK, 498 | M68K_INS_LPSTOP, 499 | M68K_INS_LSL, 500 | M68K_INS_LSR, 501 | M68K_INS_MOVE, 502 | M68K_INS_MOVEA, 503 | M68K_INS_MOVEC, 504 | M68K_INS_MOVEM, 505 | M68K_INS_MOVEP, 506 | M68K_INS_MOVEQ, 507 | M68K_INS_MOVES, 508 | M68K_INS_MOVE16, 509 | M68K_INS_MULS, 510 | M68K_INS_MULU, 511 | M68K_INS_NBCD, 512 | M68K_INS_NEG, 513 | M68K_INS_NEGX, 514 | M68K_INS_NOP, 515 | M68K_INS_NOT, 516 | M68K_INS_OR, 517 | M68K_INS_ORI, 518 | M68K_INS_PACK, 519 | M68K_INS_PEA, 520 | M68K_INS_PFLUSH, 521 | M68K_INS_PFLUSHA, 522 | M68K_INS_PFLUSHAN, 523 | M68K_INS_PFLUSHN, 524 | M68K_INS_PLOADR, 525 | M68K_INS_PLOADW, 526 | M68K_INS_PLPAR, 527 | M68K_INS_PLPAW, 528 | M68K_INS_PMOVE, 529 | M68K_INS_PMOVEFD, 530 | M68K_INS_PTESTR, 531 | M68K_INS_PTESTW, 532 | M68K_INS_PULSE, 533 | M68K_INS_REMS, 534 | M68K_INS_REMU, 535 | M68K_INS_RESET, 536 | M68K_INS_ROL, 537 | M68K_INS_ROR, 538 | M68K_INS_ROXL, 539 | M68K_INS_ROXR, 540 | M68K_INS_RTD, 541 | M68K_INS_RTE, 542 | M68K_INS_RTM, 543 | M68K_INS_RTR, 544 | M68K_INS_RTS, 545 | M68K_INS_SBCD, 546 | M68K_INS_ST, 547 | M68K_INS_SF, 548 | M68K_INS_SHI, 549 | M68K_INS_SLS, 550 | M68K_INS_SCC, 551 | M68K_INS_SHS, 552 | M68K_INS_SCS, 553 | M68K_INS_SLO, 554 | M68K_INS_SNE, 555 | M68K_INS_SEQ, 556 | M68K_INS_SVC, 557 | M68K_INS_SVS, 558 | M68K_INS_SPL, 559 | M68K_INS_SMI, 560 | M68K_INS_SGE, 561 | M68K_INS_SLT, 562 | M68K_INS_SGT, 563 | M68K_INS_SLE, 564 | M68K_INS_STOP, 565 | M68K_INS_SUB, 566 | M68K_INS_SUBA, 567 | M68K_INS_SUBI, 568 | M68K_INS_SUBQ, 569 | M68K_INS_SUBX, 570 | M68K_INS_SWAP, 571 | M68K_INS_TAS, 572 | M68K_INS_TRAP, 573 | M68K_INS_TRAPV, 574 | M68K_INS_TRAPT, 575 | M68K_INS_TRAPF, 576 | M68K_INS_TRAPHI, 577 | M68K_INS_TRAPLS, 578 | M68K_INS_TRAPCC, 579 | M68K_INS_TRAPHS, 580 | M68K_INS_TRAPCS, 581 | M68K_INS_TRAPLO, 582 | M68K_INS_TRAPNE, 583 | M68K_INS_TRAPEQ, 584 | M68K_INS_TRAPVC, 585 | M68K_INS_TRAPVS, 586 | M68K_INS_TRAPPL, 587 | M68K_INS_TRAPMI, 588 | M68K_INS_TRAPGE, 589 | M68K_INS_TRAPLT, 590 | M68K_INS_TRAPGT, 591 | M68K_INS_TRAPLE, 592 | M68K_INS_TST, 593 | M68K_INS_UNLK, 594 | M68K_INS_UNPK, 595 | M68K_INS_ENDING, // <-- mark the end of the list of instructions 596 | } m68k_insn; 597 | 598 | /// Group of M68K instructions 599 | typedef enum m68k_group_type { 600 | M68K_GRP_INVALID = 0, ///< CS_GRUP_INVALID 601 | M68K_GRP_JUMP, ///< = CS_GRP_JUMP 602 | M68K_GRP_RET = 3, ///< = CS_GRP_RET 603 | M68K_GRP_IRET = 5, ///< = CS_GRP_IRET 604 | M68K_GRP_BRANCH_RELATIVE = 7, ///< = CS_GRP_BRANCH_RELATIVE 605 | 606 | M68K_GRP_ENDING,// <-- mark the end of the list of groups 607 | } m68k_group_type; 608 | 609 | #ifdef __cplusplus 610 | } 611 | #endif 612 | 613 | #endif 614 | --------------------------------------------------------------------------------