Add conan dataset
Browse filesThis view is limited to 50 files because it contains too many changes.
See raw diff
- .gitattributes +73 -0
- datasets/conan/AMQP-CPP.json +0 -0
- datasets/conan/BehaviorTree.CPP.json +0 -0
- datasets/conan/CGNS.json +3 -0
- datasets/conan/CRoaring.json +3 -0
- datasets/conan/Celero.json +0 -0
- datasets/conan/Clipper2.json +0 -0
- datasets/conan/ComputeLibrary.json +0 -0
- datasets/conan/CppBenchmark.json +1 -0
- datasets/conan/CppCommon.json +1 -0
- datasets/conan/DSPFilters.json +1 -0
- datasets/conan/DevIL.json +0 -0
- datasets/conan/DuckX.json +0 -0
- datasets/conan/EASTL.json +0 -0
- datasets/conan/FTXUI.json +0 -0
- datasets/conan/Fast-CDR.json +1 -0
- datasets/conan/FastNoise2.json +0 -0
- datasets/conan/GENie.json +3 -0
- datasets/conan/GKlib.json +3 -0
- datasets/conan/GM2Calc.json +0 -0
- datasets/conan/Gamma.json +0 -0
- datasets/conan/HdrHistogram_c.json +0 -0
- datasets/conan/HiGHS.json +1 -0
- datasets/conan/Imath.json +0 -0
- datasets/conan/Inter-Component-Communication.json +1 -0
- datasets/conan/JWasm.json +3 -0
- datasets/conan/KTX-Software.json +1 -0
- datasets/conan/LASzip.json +0 -0
- datasets/conan/LUrlParser.json +1 -0
- datasets/conan/LibRaw.json +3 -0
- datasets/conan/LightPcapNg.json +0 -0
- datasets/conan/Little-CMS.json +3 -0
- datasets/conan/METIS.json +0 -0
- datasets/conan/MikkTSpace.json +0 -0
- datasets/conan/OpenCL-ICD-Loader.json +0 -0
- datasets/conan/OpenColorIO.json +1 -0
- datasets/conan/OpenFBX.json +0 -0
- datasets/conan/OpenJPH.json +0 -0
- datasets/conan/OpenSubdiv.json +0 -0
- datasets/conan/OpenXLSX.json +0 -0
- datasets/conan/PDF-Writer.json +3 -0
- datasets/conan/PDFGen.json +0 -0
- datasets/conan/PROJ.json +1 -0
- datasets/conan/PlatformFolders.json +0 -0
- datasets/conan/QCBOR.json +0 -0
- datasets/conan/RVO2.json +0 -0
- datasets/conan/SPIRV-Cross.json +0 -0
- datasets/conan/SQLite3MultipleCiphers.json +3 -0
- datasets/conan/SQLiteCpp.json +1 -0
- datasets/conan/SVT-JPEG-XS.json +3 -0
.gitattributes
CHANGED
|
@@ -64,3 +64,76 @@ datasets/snoopy/nginx.json filter=lfs diff=lfs merge=lfs -text
|
|
| 64 |
datasets/snoopy/openssh_portable.json filter=lfs diff=lfs merge=lfs -text
|
| 65 |
datasets/snoopy/php.json filter=lfs diff=lfs merge=lfs -text
|
| 66 |
datasets/snoopy/redis.json filter=lfs diff=lfs merge=lfs -text
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 64 |
datasets/snoopy/openssh_portable.json filter=lfs diff=lfs merge=lfs -text
|
| 65 |
datasets/snoopy/php.json filter=lfs diff=lfs merge=lfs -text
|
| 66 |
datasets/snoopy/redis.json filter=lfs diff=lfs merge=lfs -text
|
| 67 |
+
datasets/conan/apriltag.json filter=lfs diff=lfs merge=lfs -text
|
| 68 |
+
datasets/conan/asn1c.json filter=lfs diff=lfs merge=lfs -text
|
| 69 |
+
datasets/conan/aws-c-common.json filter=lfs diff=lfs merge=lfs -text
|
| 70 |
+
datasets/conan/bacnet-stack.json filter=lfs diff=lfs merge=lfs -text
|
| 71 |
+
datasets/conan/basis_universal.json filter=lfs diff=lfs merge=lfs -text
|
| 72 |
+
datasets/conan/bdwgc.json filter=lfs diff=lfs merge=lfs -text
|
| 73 |
+
datasets/conan/box2d.json filter=lfs diff=lfs merge=lfs -text
|
| 74 |
+
datasets/conan/c-blosc.json filter=lfs diff=lfs merge=lfs -text
|
| 75 |
+
datasets/conan/c-blosc2.json filter=lfs diff=lfs merge=lfs -text
|
| 76 |
+
datasets/conan/capstone.json filter=lfs diff=lfs merge=lfs -text
|
| 77 |
+
datasets/conan/cglm.json filter=lfs diff=lfs merge=lfs -text
|
| 78 |
+
datasets/conan/CGNS.json filter=lfs diff=lfs merge=lfs -text
|
| 79 |
+
datasets/conan/CRoaring.json filter=lfs diff=lfs merge=lfs -text
|
| 80 |
+
datasets/conan/crossdb.json filter=lfs diff=lfs merge=lfs -text
|
| 81 |
+
datasets/conan/crunch.json filter=lfs diff=lfs merge=lfs -text
|
| 82 |
+
datasets/conan/cyclonedds.json filter=lfs diff=lfs merge=lfs -text
|
| 83 |
+
datasets/conan/dlib.json filter=lfs diff=lfs merge=lfs -text
|
| 84 |
+
datasets/conan/duktape.json filter=lfs diff=lfs merge=lfs -text
|
| 85 |
+
datasets/conan/eudev.json filter=lfs diff=lfs merge=lfs -text
|
| 86 |
+
datasets/conan/exiv2.json filter=lfs diff=lfs merge=lfs -text
|
| 87 |
+
datasets/conan/GENie.json filter=lfs diff=lfs merge=lfs -text
|
| 88 |
+
datasets/conan/GKlib.json filter=lfs diff=lfs merge=lfs -text
|
| 89 |
+
datasets/conan/hexl.json filter=lfs diff=lfs merge=lfs -text
|
| 90 |
+
datasets/conan/innoextract.json filter=lfs diff=lfs merge=lfs -text
|
| 91 |
+
datasets/conan/jasper.json filter=lfs diff=lfs merge=lfs -text
|
| 92 |
+
datasets/conan/jemalloc.json filter=lfs diff=lfs merge=lfs -text
|
| 93 |
+
datasets/conan/JWasm.json filter=lfs diff=lfs merge=lfs -text
|
| 94 |
+
datasets/conan/leptonica.json filter=lfs diff=lfs merge=lfs -text
|
| 95 |
+
datasets/conan/lexbor.json filter=lfs diff=lfs merge=lfs -text
|
| 96 |
+
datasets/conan/libarchive.json filter=lfs diff=lfs merge=lfs -text
|
| 97 |
+
datasets/conan/libbacktrace.json filter=lfs diff=lfs merge=lfs -text
|
| 98 |
+
datasets/conan/libdeflate.json filter=lfs diff=lfs merge=lfs -text
|
| 99 |
+
datasets/conan/libdwarf-code.json filter=lfs diff=lfs merge=lfs -text
|
| 100 |
+
datasets/conan/libexif.json filter=lfs diff=lfs merge=lfs -text
|
| 101 |
+
datasets/conan/libfuse.json filter=lfs diff=lfs merge=lfs -text
|
| 102 |
+
datasets/conan/libipt.json filter=lfs diff=lfs merge=lfs -text
|
| 103 |
+
datasets/conan/libnfs.json filter=lfs diff=lfs merge=lfs -text
|
| 104 |
+
datasets/conan/LibRaw.json filter=lfs diff=lfs merge=lfs -text
|
| 105 |
+
datasets/conan/libsass.json filter=lfs diff=lfs merge=lfs -text
|
| 106 |
+
datasets/conan/libsodium.json filter=lfs diff=lfs merge=lfs -text
|
| 107 |
+
datasets/conan/libucl.json filter=lfs diff=lfs merge=lfs -text
|
| 108 |
+
datasets/conan/libxcrypt.json filter=lfs diff=lfs merge=lfs -text
|
| 109 |
+
datasets/conan/libxlsxwriter.json filter=lfs diff=lfs merge=lfs -text
|
| 110 |
+
datasets/conan/Little-CMS.json filter=lfs diff=lfs merge=lfs -text
|
| 111 |
+
datasets/conan/lodepng.json filter=lfs diff=lfs merge=lfs -text
|
| 112 |
+
datasets/conan/meshoptimizer.json filter=lfs diff=lfs merge=lfs -text
|
| 113 |
+
datasets/conan/microprofile.json filter=lfs diff=lfs merge=lfs -text
|
| 114 |
+
datasets/conan/mimalloc.json filter=lfs diff=lfs merge=lfs -text
|
| 115 |
+
datasets/conan/miniz.json filter=lfs diff=lfs merge=lfs -text
|
| 116 |
+
datasets/conan/mongo-c-driver.json filter=lfs diff=lfs merge=lfs -text
|
| 117 |
+
datasets/conan/nghttp2.json filter=lfs diff=lfs merge=lfs -text
|
| 118 |
+
datasets/conan/nghttp3.json filter=lfs diff=lfs merge=lfs -text
|
| 119 |
+
datasets/conan/nlopt.json filter=lfs diff=lfs merge=lfs -text
|
| 120 |
+
datasets/conan/nng.json filter=lfs diff=lfs merge=lfs -text
|
| 121 |
+
datasets/conan/ocilib.json filter=lfs diff=lfs merge=lfs -text
|
| 122 |
+
datasets/conan/oniguruma.json filter=lfs diff=lfs merge=lfs -text
|
| 123 |
+
datasets/conan/openjpeg.json filter=lfs diff=lfs merge=lfs -text
|
| 124 |
+
datasets/conan/PDF-Writer.json filter=lfs diff=lfs merge=lfs -text
|
| 125 |
+
datasets/conan/plutovg.json filter=lfs diff=lfs merge=lfs -text
|
| 126 |
+
datasets/conan/pupnp.json filter=lfs diff=lfs merge=lfs -text
|
| 127 |
+
datasets/conan/rebound.json filter=lfs diff=lfs merge=lfs -text
|
| 128 |
+
datasets/conan/SQLite3MultipleCiphers.json filter=lfs diff=lfs merge=lfs -text
|
| 129 |
+
datasets/conan/sundials.json filter=lfs diff=lfs merge=lfs -text
|
| 130 |
+
datasets/conan/SVT-JPEG-XS.json filter=lfs diff=lfs merge=lfs -text
|
| 131 |
+
datasets/conan/systemd-stable.json filter=lfs diff=lfs merge=lfs -text
|
| 132 |
+
datasets/conan/tidy-html5.json filter=lfs diff=lfs merge=lfs -text
|
| 133 |
+
datasets/conan/tracy.json filter=lfs diff=lfs merge=lfs -text
|
| 134 |
+
datasets/conan/usrsctp.json filter=lfs diff=lfs merge=lfs -text
|
| 135 |
+
datasets/conan/wasm-micro-runtime.json filter=lfs diff=lfs merge=lfs -text
|
| 136 |
+
datasets/conan/wildmidi.json filter=lfs diff=lfs merge=lfs -text
|
| 137 |
+
datasets/conan/xlnt.json filter=lfs diff=lfs merge=lfs -text
|
| 138 |
+
datasets/conan/yyjson.json filter=lfs diff=lfs merge=lfs -text
|
| 139 |
+
datasets/conan/zxing-cpp.json filter=lfs diff=lfs merge=lfs -text
|
datasets/conan/AMQP-CPP.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/BehaviorTree.CPP.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/CGNS.json
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:aec7204052b06ae88bd6b6b32650079e7f88e7c123043a804fd90d207529ff05
|
| 3 |
+
size 99632878
|
datasets/conan/CRoaring.json
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:232b084e4dab09df0909da24988a88dbb6ee4ab56d62af29aac6b59170cecf15
|
| 3 |
+
size 24320871
|
datasets/conan/Celero.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/Clipper2.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/ComputeLibrary.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/CppBenchmark.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"commit_hash": "a5ae04bf8acd7d835ccd2623a32824a4e2b2d468", "data": [{"file": "/src/analysis/CppBenchmark/source/benchmark/executor.cpp", "functions": [{"p_code_refined": [" --- CALL (ram, 0x1e8ac0, 8) , (unique, 0x10000031, 8) , (register, 0x30, 8) , (register, 0x10, 8)", "(ram, 0x2a9c08, 8) INDIRECT (ram, 0x2a9c08, 8) , (const, 0x23, 4)", "(unique, 0x10000031, 8) PTRSUB (register, 0x38, 8) , (const, 0x0, 4)", "(unique, 0x3100, 8) PTRADD (ram, 0x2a9c08, 8) , (const, 0x10, 8) , (const, 0x1, 8)", " --- STORE (const, 0x1b1, 4) , (unique, 0x10000029, 8) , (unique, 0x10000039, 8)", "(ram, 0x2a9c08, 8) INDIRECT (ram, 0x2a9c08, 8) , (const, 0x2b, 4)", "(unique, 0x10000021, 8) PTRSUB (register, 0x38, 8) , (const, 0x0, 8)", "(unique, 0x10000029, 8) PTRSUB (unique, 0x10000021, 8) , (const, 0x0, 8)", "(unique, 0x10000039, 8) CAST (unique, 0x3100, 8)", " --- RETURN (const, 0x0, 8)", "(ram, 0x2a9c08, 8) COPY (ram, 0x2a9c08, 8)"], "raw": ["f30f1efa", "55", "4889e5", "4883ec20", "48897df8", "488975f0", "488955e8", "488b45f8", "488b55e8", "488b4df0", "4889ce", "4889c7", "e81f26fbff", "488b0560370700", "488d5010", "488b45f8", "488910", "90", "c9", "c3"], "c_code": "\n/* DWARF original prototype: void DynamicBenchmark(DynamicBenchmark * this, string * name, TSettings\n * settings) */\n\nvoid __thiscall\nCppBenchmark::Internals::DynamicBenchmark::DynamicBenchmark\n (DynamicBenchmark *this,string *name,TSettings *settings)\n\n{\n TSettings *settings_local;\n string *name_local;\n DynamicBenchmark *this_local;\n \n BenchmarkBase::BenchmarkBase(&this->super_BenchmarkBase,name,settings);\n (this->super_BenchmarkBase)._vptr_BenchmarkBase =\n (_func_int_varargs **)(PTR_vtable_002a9c08 + 0x10);\n return;\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_LESS (register, 0x20, 8) , (const, 0x20, 8), (register, 0x20b, 1) INT_SBORROW (register, 0x20, 8) , (const, 0x20, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x20, 8), (register, 0x207, 1) INT_SLESS (register, 0x20, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x20, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x20, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0x5500, 8) COPY (register, 0x38, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0x5500, 8) COPY (register, 0x30, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0x5500, 8) COPY (register, 0x10, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x10, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x8, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (register, 0x8, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x2364a1, 8), --- CALL (ram, 0x1e8ac0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x0, 8) COPY (ram, 0x2a9c08, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x0, 8) , (const, 0x10, 8), (register, 0x10, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x5500, 8) COPY (register, 0x10, 8), --- STORE (const, 0x1b1, 4) , (register, 0x0, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) COPY (register, 0x28, 8), (register, 0x28, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "DynamicBenchmark", "assembly": ["ENDBR64", "PUSH RBP", "MOV RBP,RSP", "SUB RSP,0x20", "MOV qword ptr [RBP + -0x8],RDI", "MOV qword ptr [RBP + -0x10],RSI", "MOV qword ptr [RBP + -0x18],RDX", "MOV RAX,qword ptr [RBP + -0x8]", "MOV RDX,qword ptr [RBP + -0x18]", "MOV RCX,qword ptr [RBP + -0x10]", "MOV RSI,RCX", "MOV RDI,RAX", "CALL 0x001e8ac0", "MOV RAX,qword ptr [0x002a9c08]", "LEA RDX,[RAX + 0x10]", "MOV RAX,qword ptr [RBP + -0x8]", "MOV qword ptr [RAX],RDX", "NOP", "LEAVE", "RET"], "code": " explicit DynamicBenchmark(const std::string& name, const TSettings& settings = TSettings())\n : BenchmarkBase(name, settings)\n {}\n", "authors": {"chronoxor": 0.9722222222222222, "Ivan Shynkarenka": 0.027777777777777776}, "leading_author": "chronoxor", "total_score": 144.0, "unique": true}]}, {"file": "/src/analysis/CppBenchmark/examples/timers.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n/* WARNING: Unknown calling convention -- yet parameter storage is locked */\n\nint clock_gettime(clockid_t __clock_id,timespec *__tp)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n /* clock_gettime@@GLIBC_2.17 */\n halt_baddata();\n}\n\n", "p_code": [], "name": "clock_gettime", "assembly": [], "code": "struct timespec clock_gettime(clockid_t clockid)\n{\n struct timespec current;\n clock_gettime(clockid, ¤t);\n return current;\n}\n", "authors": {"Ivan Shynkarenka": 1.0}, "leading_author": "Ivan Shynkarenka", "total_score": 134.0, "unique": true}]}]}
|
datasets/conan/CppCommon.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"commit_hash": "7f88543eae636887729653eb958b900da120bafb", "data": [{"file": "/src/analysis/CppCommon/plugins/function/function.cpp", "functions": [{"p_code_refined": ["(register, 0x0, 4) CALL (ram, 0x101050, 8)", " --- RETURN (const, 0x0, 8) , (register, 0x0, 4)"], "raw": ["f30f1efa", "55", "4889e5", "e82affffff", "5d", "c3"], "c_code": "\n/* WARNING: Unknown calling convention */\n\nint PluginRandom(void)\n\n{\n int iVar1;\n \n iVar1 = FUN_00101050();\n return iVar1;\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x101126, 8), --- CALL (ram, 0x101050, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3c380, 8) COPY (const, 0x0, 8), (unique, 0x3c380, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), (register, 0x28, 8) COPY (unique, 0x3c380, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "PluginRandom", "assembly": ["ENDBR64", "PUSH RBP", "MOV RBP,RSP", "CALL 0x00101050", "POP RBP", "RET"], "code": "API int PluginRandom()\n{\n return std::rand();\n}\n", "authors": {"Ivan Shynkarenka": 1.0}, "leading_author": "Ivan Shynkarenka", "total_score": 46.0, "unique": true}]}]}
|
datasets/conan/DSPFilters.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"commit_hash": "acc49170e79a94fcb9c04b8a2116e9f8dffd1c7d", "data": [{"file": "/src/analysis/DSPFilters/shared/JuceAmalgam/juce_core_amalgam.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n/* WARNING: Unknown calling convention -- yet parameter storage is locked */\n\ndouble exp(double __x)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n /* exp@@GLIBC_2.29 */\n halt_baddata();\n}\n\n", "p_code": [], "name": "exp", "assembly": [], "code": "\tBigInteger exp (exponent);\n\texp %= modulus;\n\n\tBigInteger value (1);\n\tswapWith (value);\n\tvalue %= modulus;\n\n\twhile (! exp.isZero())\n\t{\n\t\tif (exp [0])\n\t\t{\n\t\t\toperator*= (value);\n\t\t\toperator%= (modulus);\n\t\t}\n\n\t\tvalue *= value;\n\t\tvalue %= modulus;\n\t\texp >>= 1;\n\t}\n", "authors": {"Vinnie Falco": 1.0}, "leading_author": "Vinnie Falco", "total_score": 242.0, "unique": true}]}]}
|
datasets/conan/DevIL.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/DuckX.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/EASTL.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/FTXUI.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/Fast-CDR.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"commit_hash": "9f4e60f7ac958e0fbbfe949102de3929cbbc226f", "data": [{"file": "/src/analysis/Fast-CDR/src/cpp/Cdr.cpp", "functions": [{"p_code_refined": ["(register, 0x0, 8) CALL (ram, 0x10e480, 8) , (register, 0x30, 8) , (register, 0x38, 8)", "(register, 0x10, 8) INT_REM (register, 0x0, 8) , (register, 0x10, 8)", "(register, 0x0, 8) INT_SUB (register, 0x10, 8) , (register, 0x10, 8)", "(register, 0x0, 8) INT_SUB (register, 0x10, 8) , (const, 0x1, 8)", "(register, 0x0, 8) INT_AND (register, 0x0, 8) , (register, 0x0, 8)", " --- RETURN (const, 0x0, 8) , (register, 0x0, 8)"], "raw": ["f30f1efa", "55", "4889e5", "4883ec20", "48897df8", "488975f0", "488955e8", "488b55f8", "488b45f0", "4889d6", "4889c7", "e81130ffff", "ba00000000", "48f775e8", "488b45e8", "4829d0", "4889c2", "488b45e8", "4883e801", "4821d0", "c9", "c3"], "c_code": "\nsize_t eprosima::fastcdr::alignment_on_state(iterator *origin,iterator *offset,size_t data_size)\n\n{\n size_t sVar1;\n size_t data_size_local;\n iterator *offset_local;\n iterator *origin_local;\n \n sVar1 = _FastBuffer_iterator::operator-(offset,origin);\n return data_size - 1 & data_size - sVar1 % data_size;\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_LESS (register, 0x20, 8) , (const, 0x20, 8), (register, 0x20b, 1) INT_SBORROW (register, 0x20, 8) , (const, 0x20, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x20, 8), (register, 0x207, 1) INT_SLESS (register, 0x20, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x20, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x20, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0x5500, 8) COPY (register, 0x38, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0x5500, 8) COPY (register, 0x30, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0x5500, 8) COPY (register, 0x10, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x10, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (register, 0x10, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x11b46f, 8), --- CALL (ram, 0x10e480, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x10, 8) COPY (const, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (unique, 0x2b480, 16) INT_ZEXT (unique, 0xc300, 8), (unique, 0x2b500, 16) INT_ZEXT (register, 0x10, 8), (unique, 0x2b580, 16) INT_LEFT (unique, 0x2b500, 16) , (const, 0x40, 4), (unique, 0x2b600, 16) INT_ZEXT (register, 0x0, 8), (unique, 0x2b700, 16) INT_OR (unique, 0x2b580, 16) , (unique, 0x2b600, 16), (unique, 0x2b800, 16) INT_DIV (unique, 0x2b700, 16) , (unique, 0x2b480, 16), (register, 0x0, 8) SUBPIECE (unique, 0x2b800, 16) , (const, 0x0, 4), (unique, 0x2b980, 16) INT_REM (unique, 0x2b700, 16) , (unique, 0x2b480, 16), (register, 0x10, 8) SUBPIECE (unique, 0x2b980, 16) , (const, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_LESS (register, 0x0, 8) , (register, 0x10, 8), (register, 0x20b, 1) INT_SBORROW (register, 0x0, 8) , (register, 0x10, 8), (register, 0x0, 8) INT_SUB (register, 0x0, 8) , (register, 0x10, 8), (register, 0x207, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x0, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x10, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_LESS (register, 0x0, 8) , (const, 0x1, 8), (register, 0x20b, 1) INT_SBORROW (register, 0x0, 8) , (const, 0x1, 8), (register, 0x0, 8) INT_SUB (register, 0x0, 8) , (const, 0x1, 8), (register, 0x207, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x0, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (register, 0x0, 8) INT_AND (register, 0x0, 8) , (register, 0x10, 8), (register, 0x207, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x0, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) COPY (register, 0x28, 8), (register, 0x28, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "alignment_on_state", "assembly": ["ENDBR64", "PUSH RBP", "MOV RBP,RSP", "SUB RSP,0x20", "MOV qword ptr [RBP + -0x8],RDI", "MOV qword ptr [RBP + -0x10],RSI", "MOV qword ptr [RBP + -0x18],RDX", "MOV RDX,qword ptr [RBP + -0x8]", "MOV RAX,qword ptr [RBP + -0x10]", "MOV RSI,RDX", "MOV RDI,RAX", "CALL 0x0010e480", "MOV EDX,0x0", "DIV qword ptr [RBP + -0x18]", "MOV RAX,qword ptr [RBP + -0x18]", "SUB RAX,RDX", "MOV RDX,RAX", "MOV RAX,qword ptr [RBP + -0x18]", "SUB RAX,0x1", "AND RAX,RDX", "LEAVE", "RET"], "code": "inline size_t alignment_on_state(\n const FastBuffer::iterator& origin,\n const FastBuffer::iterator& offset,\n size_t data_size)\n{\n return (data_size - ((offset - origin) % data_size)) & (data_size - 1);\n}\n", "authors": {"Ricardo Gonz\u00e1lez": 1.0}, "leading_author": "Ricardo Gonz\u00e1lez", "total_score": 221.0, "unique": true}]}]}
|
datasets/conan/FastNoise2.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/GENie.json
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:37dd629dda6f1ec3e67c72fdd63ca2ec8e2156b6d6a74cd14cf6b66d787c65f0
|
| 3 |
+
size 23403070
|
datasets/conan/GKlib.json
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:4e7b1f8e222841796eb73e50a9c810b8794127a03615aafc2a5af5679e13fc3e
|
| 3 |
+
size 14603765
|
datasets/conan/GM2Calc.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/Gamma.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/HdrHistogram_c.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/HiGHS.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"commit_hash": "4a7f24ac63b3832e30694969e0a69a4b3c1f1674", "data": [{"file": "/src/analysis/HiGHS/src/lp_data/HighsOptions.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n/* WARNING: Unknown calling convention -- yet parameter storage is locked */\n\nvoid writeOptionsToFile(_IO_FILE *param_1,vector *param_2,bool param_3,HighsFileType param_4)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "writeOptionsToFile", "assembly": [], "code": "HighsStatus writeOptionsToFile(FILE* file,\n const std::vector<OptionRecord*>& option_records,\n const bool report_only_deviations,\n const HighsFileType file_type) {\n reportOptions(file, option_records, report_only_deviations, file_type);\n return HighsStatus::kOk;\n}\n", "authors": {"Julian Hall": 0.7770897832817337, "Hall": 0.21981424148606812, "Ivet": 0.0030959752321981426}, "leading_author": "Julian Hall", "total_score": 323.0, "unique": true}]}, {"file": "/src/analysis/HiGHS/src/util/stringutil.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n/* WARNING: Unknown calling convention -- yet parameter storage is locked */\n\nvoid trim(basic_string *param_1,basic_string *param_2)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "trim", "assembly": [], "code": "std::string& trim(std::string& str, const std::string& chars) {\n return ltrim(rtrim(str, chars), chars);\n}\n", "authors": {"Ivet": 0.6, "Ivet GALABOVA": 0.4}, "leading_author": "Ivet", "total_score": 105.0, "unique": true}]}, {"file": "/src/analysis/HiGHS/src/io/LoadOptions.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid loadOptionsFromFile(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "loadOptionsFromFile", "assembly": [], "code": "HighsLoadOptionsStatus loadOptionsFromFile(\n const HighsLogOptions& report_log_options, HighsOptions& options,\n const std::string filename) {\n if (filename.size() == 0) return HighsLoadOptionsStatus::kEmpty;\n\n string line, option, value;\n HighsInt line_count = 0;\n // loadOptionsFromFile needs its own non-chars string since the\n // default setting in io/stringutil.h excludes \\\" and \\' that can\n // appear in an MPS name - the only other place where trim() is used\n const std::string non_chars = \"\\t\\n\\v\\f\\r\\\"\\' \";\n std::ifstream file(filename);\n if (file.is_open()) {\n while (file.good()) {\n getline(file, line);\n line_count++;\n if (line.size() == 0 || line[0] == '#') continue;\n\n size_t equals = line.find_first_of(\"=\");\n if (equals == std::string::npos || equals + 1 >= line.size()) {\n highsLogUser(report_log_options, HighsLogType::kError,\n \"Error on line %\" HIGHSINT_FORMAT \" of options file.\\n\",\n line_count);\n return HighsLoadOptionsStatus::kError;\n }\n option = line.substr(0, equals);\n value = line.substr(equals + 1, line.size() - equals);\n trim(option, non_chars);\n trim(value, non_chars);\n if (setLocalOptionValue(report_log_options, option, options.log_options,\n options.records, value) != OptionStatus::kOk) {\n highsLogUser(report_log_options, HighsLogType::kError,\n \"Cannot read value \\\"%s\\\" for option \\\"%s\\\"\\n\",\n value.c_str(), option.c_str());\n return HighsLoadOptionsStatus::kError;\n }\n }\n } else {\n highsLogUser(report_log_options, HighsLogType::kError,\n \"Options file not found\\n\");\n return HighsLoadOptionsStatus::kError;\n }\n\n return HighsLoadOptionsStatus::kOk;\n}\n", "authors": {"Hall": 0.17442512619181155, "Julian Hall": 0.6461020751542345, "Leona Gottwald": 0.034212002243409985, "fwesselm": 0.024677509814918678, "jajhall": 0.10600112170499158, "Ivet": 0.014582164890633763}, "leading_author": "Julian Hall", "total_score": 1783.0, "unique": true}]}, {"file": "/src/analysis/HiGHS/src/io/HighsIO.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n/* WARNING: Unknown calling convention -- yet parameter storage is locked */\n\nvoid highsLogUser(HighsLogOptions *param_1,HighsLogType param_2,char *param_3,...)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "highsLogUser", "assembly": [], "code": "void highsLogUser(const HighsLogOptions& log_options_, const HighsLogType type,\n const char* format, ...) {\n if (!*log_options_.output_flag ||\n (log_options_.log_stream == NULL && !*log_options_.log_to_console))\n return;\n // highsLogUser should not be passed HighsLogType::kDetailed or\n // HighsLogType::kVerbose\n assert(type != HighsLogType::kDetailed);\n assert(type != HighsLogType::kVerbose);\n const bool prefix =\n type == HighsLogType::kWarning || type == HighsLogType::kError;\n va_list argptr;\n va_start(argptr, format);\n const bool flush_streams = true;\n const bool use_log_callback =\n log_options_.user_log_callback ||\n (log_options_.user_callback && log_options_.user_callback_active);\n\n if (!use_log_callback) {\n // Write to log file stream unless it is NULL\n if (log_options_.log_stream) {\n if (prefix)\n fprintf(log_options_.log_stream, \"%-9s\", HighsLogTypeTag[(int)type]);\n vfprintf(log_options_.log_stream, format, argptr);\n if (flush_streams) fflush(log_options_.log_stream);\n va_end(argptr);\n va_start(argptr, format);\n }\n // Write to stdout unless log file stream is stdout\n if (*log_options_.log_to_console && log_options_.log_stream != stdout) {\n if (prefix) fprintf(stdout, \"%-9s\", HighsLogTypeTag[(int)type]);\n vfprintf(stdout, format, argptr);\n if (flush_streams) fflush(stdout);\n }\n } else {\n size_t len = 0;\n std::array<char, kIoBufferSize> msgbuffer = {};\n if (prefix) {\n int l = snprintf(msgbuffer.data(), msgbuffer.size(), \"%-9s\",\n HighsLogTypeTag[(int)type]);\n // assert that there are no encoding errors\n assert(l >= 0);\n len = static_cast<size_t>(l);\n }\n if (len < msgbuffer.size()) {\n int l = vsnprintf(msgbuffer.data() + len, msgbuffer.size() - len, format,\n argptr);\n // assert that there are no encoding errors\n assert(l >= 0);\n len += static_cast<size_t>(l);\n }\n if (log_options_.user_log_callback) {\n log_options_.user_log_callback(type, msgbuffer.data(),\n log_options_.user_log_callback_data);\n }\n if (log_options_.user_callback_active) {\n assert(log_options_.user_callback);\n HighsCallbackDataOut data_out;\n data_out.log_type = int(type);\n log_options_.user_callback(kCallbackLogging, msgbuffer.data(), &data_out,\n nullptr, log_options_.user_callback_data);\n }\n }\n va_end(argptr);\n}\n", "authors": {"Julian Hall": 0.4910931174089069, "Michael Feldmeier": 0.029554655870445343, "JAJHall": 0.28016194331983807, "Leona Gottwald": 0.01700404858299595, "Gabriel Gouvine": 0.008502024291497975, "fwesselm": 0.14736842105263157, "Stefan Vigerske": 0.024696356275303644, "Hall": 0.0016194331983805667}, "leading_author": "Julian Hall", "total_score": 2470.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n/* WARNING: Unknown calling convention -- yet parameter storage is locked */\n\nvoid highsLogDev(HighsLogOptions *param_1,HighsLogType param_2,char *param_3,...)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "highsLogDev", "assembly": [], "code": "void highsLogDev(const HighsLogOptions& log_options_, const HighsLogType type,\n const char* format, ...) {\n if (!*log_options_.output_flag ||\n (log_options_.log_stream == NULL && !*log_options_.log_to_console) ||\n !*log_options_.log_dev_level)\n return;\n // Always report HighsLogType::kInfo, HighsLogType::kWarning or\n // HighsLogType::kError\n //\n // Report HighsLogType::kDetailed if *log_options_.log_dev_level >=\n // kHighsLogDevLevelDetailed\n //\n // Report HighsLogType::kVerbose if *log_options_.log_dev_level >=\n // kHighsLogDevLevelVerbose\n if (type == HighsLogType::kDetailed &&\n *log_options_.log_dev_level < kHighsLogDevLevelDetailed)\n return;\n if (type == HighsLogType::kVerbose &&\n *log_options_.log_dev_level < kHighsLogDevLevelVerbose)\n return;\n va_list argptr;\n va_start(argptr, format);\n const bool flush_streams = true;\n const bool use_log_callback =\n log_options_.user_log_callback ||\n (log_options_.user_callback && log_options_.user_callback_active);\n if (!use_log_callback) {\n // Write to log file stream unless it is NULL\n if (log_options_.log_stream) {\n // Write to log file stream\n vfprintf(log_options_.log_stream, format, argptr);\n if (flush_streams) fflush(log_options_.log_stream);\n va_end(argptr);\n va_start(argptr, format);\n }\n // Write to stdout unless log file stream is stdout\n if (*log_options_.log_to_console && log_options_.log_stream != stdout) {\n vfprintf(stdout, format, argptr);\n if (flush_streams) fflush(stdout);\n }\n } else {\n std::array<char, kIoBufferSize> msgbuffer = {};\n int len = vsnprintf(msgbuffer.data(), msgbuffer.size(), format, argptr);\n // assert that there are no encoding errors\n assert(len >= 0);\n if (log_options_.user_log_callback) {\n log_options_.user_log_callback(type, msgbuffer.data(),\n log_options_.user_log_callback_data);\n } else if (log_options_.user_callback_active) {\n assert(log_options_.user_callback);\n HighsCallbackDataOut data_out;\n data_out.log_type = int(type);\n log_options_.user_callback(kCallbackLogging, msgbuffer.data(), &data_out,\n nullptr, log_options_.user_callback_data);\n }\n }\n va_end(argptr);\n}\n", "authors": {"Julian Hall": 0.5397752808988764, "Ivet": 0.03550561797752809, "Michael Feldmeier": 0.03415730337078652, "JAJHall": 0.2844943820224719, "Leona Gottwald": 0.01887640449438202, "Gabriel Gouvine": 0.00943820224719101, "Stefan Vigerske": 0.00853932584269663, "fwesselm": 0.06741573033707865, "Hall": 0.0017977528089887641}, "leading_author": "Julian Hall", "total_score": 2225.0, "unique": true}]}, {"file": "/src/analysis/HiGHS/check/TestLpSolvers.cpp", "functions": [{"p_code_refined": ["(unique, 0x1000013d, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8)", "(unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8)", "(unique, 0x4f00, 8) CAST (unique, 0x1000013d, 8)", " --- CALL (ram, 0x10a110, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x30, 4)", "(stack, 0xfffffffffffffe30, 8) INDIRECT (stack, 0xfffffffffffffe30, 8) , (const, 0x30, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (unique, 0xc300, 8) , (const, 0x30, 4)", "(register, 0x10, 4) INT_SEXT (register, 0x30, 1)", "(unique, 0x10000149, 8) INT_ZEXT (unique, 0x10000145, 4)", "(unique, 0x10000145, 4) CAST (register, 0x10, 4)", "(register, 0x10, 8) CAST (unique, 0x10000149, 8)", "(unique, 0x3200, 8) PTRSUB (register, 0x20, 8) , (const, 0xfffffffffffffe38, 8)", " --- CALL (ram, 0x109ba0, 8) , (unique, 0x10000151, 8) , (const, 0x1, 1) , (register, 0x10, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x3d, 4)", "(stack, 0xfffffffffffffe30, 8) INDIRECT (stack, 0xfffffffffffffe30, 8) , (const, 0x3d, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x3d, 4)", "(unique, 0x10000151, 8) CAST (unique, 0x3200, 8)", "(unique, 0x3200, 8) PTRSUB (register, 0x20, 8) , (const, 0xfffffffffffffe38, 8)", "(unique, 0x3200, 8) PTRSUB (register, 0x20, 8) , (const, 0xfffffffffffffe58, 8)", " --- CALL (ram, 0x10a080, 8) , (unique, 0x3200, 8) , (register, 0x30, 4)", "(register, 0x30, 4) SUBPIECE (unique, 0x3200, 8) , (const, 0x0, 4)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x47, 4)", "(stack, 0xfffffffffffffe30, 8) INDIRECT (stack, 0xfffffffffffffe30, 8) , (const, 0x47, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x47, 4)", "(unique, 0x3200, 8) PTRSUB (register, 0x20, 8) , (const, 0xfffffffffffffe38, 8)", " --- CALL (ram, 0x109920, 8) , (unique, 0x3200, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x4d, 4)", "(stack, 0xfffffffffffffe30, 8) INDIRECT (stack, 0xfffffffffffffe30, 8) , (const, 0x4d, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x4d, 4)", "(unique, 0x3200, 8) PTRSUB (register, 0x20, 8) , (const, 0xfffffffffffffe30, 8)", " --- CALL (ram, 0x109e00, 8) , (unique, 0x10000159, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x53, 4)", "(stack, 0xfffffffffffffe30, 8) INDIRECT (stack, 0xfffffffffffffe30, 8) , (const, 0x53, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x53, 4)", "(unique, 0x10000159, 8) CAST (unique, 0x3200, 8)", "(register, 0x206, 1) INT_EQUAL (register, 0x10, 4) , (const, 0x8, 4)", " --- CBRANCH (ram, 0x15abc4, 1) , (register, 0x206, 1)", "(unique, 0x10000169, 8) PTRSUB (register, 0x20, 8) , (const, 0xfffffffffffffe58, 8)", "(unique, 0x3200, 8) CAST (unique, 0x10000169, 8)", " --- CALL (ram, 0x10a070, 8) , (unique, 0x3200, 8) , (unique, 0x100000e5, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x68, 4)", "(stack, 0xfffffffffffffe30, 8) INDIRECT (stack, 0xfffffffffffffe30, 8) , (const, 0x68, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x68, 4)", "(unique, 0x100000e5, 8) PTRSUB (const, 0x0, 8) , (const, 0x10a726, 8)", " --- BRANCH (ram, 0x15abe3, 1)", "(register, 0x206, 1) INT_EQUAL (register, 0x10, 4) , (const, 0x10, 4)", " --- CBRANCH (ram, 0x15abe3, 1) , (register, 0x206, 1)", "(unique, 0x10000161, 8) PTRSUB (register, 0x20, 8) , (const, 0xfffffffffffffe58, 8)", "(unique, 0x3200, 8) CAST (unique, 0x10000161, 8)", " --- CALL (ram, 0x10a070, 8) , (unique, 0x3200, 8) , (unique, 0x100000dd, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0xd8, 4)", "(stack, 0xfffffffffffffe30, 8) INDIRECT (stack, 0xfffffffffffffe30, 8) , (const, 0xd8, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0xd8, 4)", "(unique, 0x100000dd, 8) PTRSUB (const, 0x0, 8) , (const, 0x10a6fa, 8)", "(register, 0x110, 8) MULTIEQUAL (register, 0x110, 8) , (register, 0x110, 8) , (register, 0x110, 8)", "(stack, 0xfffffffffffffe30, 8) MULTIEQUAL (stack, 0xfffffffffffffe30, 8) , (stack, 0xfffffffffffffe30, 8) , (stack, 0xfffffffffffffe30, 8)", "(stack, 0xffffffffffffffe0, 8) MULTIEQUAL (stack, 0xffffffffffffffe0, 8) , (stack, 0xffffffffffffffe0, 8) , (stack, 0xffffffffffffffe0, 8)", "(unique, 0x3200, 8) PTRSUB (register, 0x20, 8) , (const, 0xfffffffffffffe30, 8)", "(unique, 0x10000171, 8) PTRSUB (register, 0x20, 8) , (const, 0xfffffffffffffe58, 8)", "(unique, 0x3200, 8) CAST (unique, 0x10000171, 8)", " --- CALL (ram, 0x109b40, 8) , (unique, 0x3200, 8) , (unique, 0x10000179, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x72, 4)", "(stack, 0xfffffffffffffe30, 8) INDIRECT (stack, 0xfffffffffffffe30, 8) , (const, 0x72, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x72, 4)", "(unique, 0x10000179, 8) CAST (unique, 0x3200, 8)", "(register, 0x0, 1) CALL (ram, 0x109930, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x81, 4)", "(stack, 0xfffffffffffffe30, 8) INDIRECT (stack, 0xfffffffffffffe30, 8) , (const, 0x81, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x81, 4)", "(register, 0x206, 1) INT_EQUAL (register, 0x0, 1) , (const, 0x0, 1)", " --- CBRANCH (ram, 0x15ac1a, 1) , (register, 0x206, 1)", "(register, 0x18, 8) COPY (const, 0xffffffff, 8)", " --- BRANCH (ram, 0x15ac23, 1)", "(register, 0x18, 8) INT_AND (stack, 0xfffffffffffffe30, 8) , (const, 0xffffffff, 8)", "(register, 0x18, 8) MULTIEQUAL (register, 0x18, 8) , (register, 0x18, 8)", "(unique, 0x10000181, 8) PTRSUB (register, 0x20, 8) , (const, 0xfffffffffffffe58, 8)", "(unique, 0x3200, 8) CAST (unique, 0x10000181, 8)", " --- CALL (ram, 0x109ac0, 8) , (unique, 0x3200, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x93, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x93, 4)", "(register, 0x0, 8) COPY (register, 0x18, 8)", "(unique, 0x10000189, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8)", "(unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8)", "(register, 0x206, 1) INT_NOTEQUAL (stack, 0xffffffffffffffe0, 8) , (unique, 0xc300, 8)", "(unique, 0x4f00, 8) CAST (unique, 0x10000189, 8)", " --- CBRANCH (ram, 0x15aca4, 1) , (register, 0x206, 1)", " --- CALL (ram, 0x109e70, 8)", " --- RETURN (const, 0x1, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0xa8, 4)", " --- RETURN (const, 0x0, 8) , (register, 0x0, 8)"], "raw": ["55", "4889e5", "53", "4881ecd8010000", "4889bd28feffff", "89f0", "899520feffff", "888524feffff", "64488b042528000000", "488945e8", "31c0", "488d8538feffff", "4889c7", "e8cbf5faff", "0fbe9524feffff", "488d8d38feffff", "488d8540feffff", "be01000000", "4889c7", "e839f0faff", "488d8d40feffff", "488d8560feffff", "ba08000000", "4889ce", "4889c7", "e8fbf4faff", "488d8540feffff", "4889c7", "e88cedfaff", "488d8538feffff", "4889c7", "e85df2faff", "83bd20feffff08", "7518", "488d8560feffff", "488d356cfbfaff", "4889c7", "e8aef4faff", "eb1f", "83bd20feffff10", "7516", "488d8560feffff", "488d351ffbfaff", "4889c7", "e88df4faff", "488d9538feffff", "488d8560feffff", "4889d6", "4889c7", "e844effaff", "488d8560feffff", "4883c078", "4889c7", "e821edfaff", "84c0", "7407", "bbffffffff", "eb09", "488b8538feffff", "89c3", "488d8560feffff", "4889c7", "e88eeefaff", "89d8", "488b4de8", "6448330c2528000000", "7461", "eb5a", "e8ccf1faff", "4881c4d8010000", "5b", "5d", "c3"], "c_code": "\n/* std::__cxx11::regex_traits<char>::value(char, int) const */\n\nulong __thiscall\nstd::__cxx11::regex_traits<char>::value(regex_traits<char> *this,char param_1,int param_2)\n\n{\n char cVar1;\n ulong uVar2;\n long in_FS_OFFSET;\n ulong local_1d0;\n basic_string<char,std::char_traits<char>,std::allocator<char>> local_1c8 [32];\n basic_string local_1a8 [392];\n long local_20;\n \n local_20 = *(long *)(in_FS_OFFSET + 0x28);\n std::allocator<char>::allocator();\n /* try { // try from 0015ab62 to 0015ab66 has its CatchHandler @ 0015ac5d */\n std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string\n ((ulong)local_1c8,'\\x01',(allocator *)(ulong)(uint)(int)param_1);\n /* try { // try from 0015ab80 to 0015ab84 has its CatchHandler @ 0015ac45 */\n std::__cxx11::basic_istringstream<char,std::char_traits<char>,std::allocator<char>>::\n basic_istringstream(local_1a8,(_Ios_Openmode)local_1c8);\n std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string\n (local_1c8);\n std::allocator<char>::~allocator((allocator<char> *)&local_1d0);\n if (param_2 == 8) {\n /* try { // try from 0015abbd to 0015ac0e has its CatchHandler @ 0015ac7e */\n std::basic_istream<char,std::char_traits<char>>::operator>>\n ((basic_istream<char,std::char_traits<char>> *)local_1a8,oct);\n }\n else if (param_2 == 0x10) {\n std::basic_istream<char,std::char_traits<char>>::operator>>\n ((basic_istream<char,std::char_traits<char>> *)local_1a8,hex);\n }\n std::basic_istream<char,std::char_traits<char>>::operator>>\n ((basic_istream<char,std::char_traits<char>> *)local_1a8,(long *)&local_1d0);\n cVar1 = std::basic_ios<char,std::char_traits<char>>::fail();\n if (cVar1 == '\\0') {\n uVar2 = local_1d0 & 0xffffffff;\n }\n else {\n uVar2 = 0xffffffff;\n }\n std::__cxx11::basic_istringstream<char,std::char_traits<char>,std::allocator<char>>::\n ~basic_istringstream\n ((basic_istringstream<char,std::char_traits<char>,std::allocator<char>> *)local_1a8);\n if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {\n /* WARNING: Subroutine does not return */\n __stack_chk_fail();\n }\n return uVar2;\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x18, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_LESS (register, 0x20, 8) , (const, 0x1d8, 8), (register, 0x20b, 1) INT_SBORROW (register, 0x20, 8) , (const, 0x1d8, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x1d8, 8), (register, 0x207, 1) INT_SLESS (register, 0x20, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x20, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x20, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe28, 8), (unique, 0x5500, 8) COPY (register, 0x38, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x0, 4) COPY (register, 0x30, 4), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe20, 8), (unique, 0x5480, 4) COPY (register, 0x10, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5480, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe24, 8), (unique, 0x5380, 1) COPY (register, 0x0, 1), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5380, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x4f00, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (register, 0x0, 4) INT_XOR (register, 0x0, 4) , (register, 0x0, 4), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4), (register, 0x207, 1) INT_SLESS (register, 0x0, 4) , (const, 0x0, 4), (register, 0x206, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x0, 4), (unique, 0x13480, 4) INT_AND (register, 0x0, 4) , (const, 0xff, 4), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 4), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe38, 8), (register, 0x0, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x15ab45, 8), --- CALL (ram, 0x10a110, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe24, 8), (unique, 0xc080, 1) LOAD (const, 0x1b1, 4) , (unique, 0x3200, 8), (register, 0x10, 4) INT_SEXT (unique, 0xc080, 1), (register, 0x10, 8) INT_ZEXT (register, 0x10, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe38, 8), (register, 0x8, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe40, 8), (register, 0x0, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (const, 0x1, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x15ab67, 8), --- CALL (ram, 0x109ba0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe40, 8), (register, 0x8, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe60, 8), (register, 0x0, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x10, 8) COPY (const, 0x8, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (register, 0x8, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x15ab85, 8), --- CALL (ram, 0x10a080, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe40, 8), (register, 0x0, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x15ab94, 8), --- CALL (ram, 0x109920, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe38, 8), (register, 0x0, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x15aba3, 8), --- CALL (ram, 0x109e00, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe20, 8), (unique, 0xc280, 4) LOAD (const, 0x1b1, 4) , (unique, 0x3200, 8), (unique, 0x25a00, 4) COPY (unique, 0xc280, 4), (register, 0x200, 1) INT_LESS (unique, 0x25a00, 4) , (const, 0x8, 4), (register, 0x20b, 1) INT_SBORROW (unique, 0x25a00, 4) , (const, 0x8, 4), (unique, 0x25b00, 4) INT_SUB (unique, 0x25a00, 4) , (const, 0x8, 4), (register, 0x207, 1) INT_SLESS (unique, 0x25b00, 4) , (const, 0x0, 4), (register, 0x206, 1) INT_EQUAL (unique, 0x25b00, 4) , (const, 0x0, 4), (unique, 0x13480, 4) INT_AND (unique, 0x25b00, 4) , (const, 0xff, 4), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 4), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xcc00, 1) BOOL_NEGATE (register, 0x206, 1), --- CBRANCH (ram, 0x15abc4, 8) , (unique, 0xcc00, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe60, 8), (register, 0x0, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (const, 0x10a726, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x15abc2, 8), --- CALL (ram, 0x10a070, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- BRANCH (ram, 0x15abe3, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe20, 8), (unique, 0xc280, 4) LOAD (const, 0x1b1, 4) , (unique, 0x3200, 8), (unique, 0x25a00, 4) COPY (unique, 0xc280, 4), (register, 0x200, 1) INT_LESS (unique, 0x25a00, 4) , (const, 0x10, 4), (register, 0x20b, 1) INT_SBORROW (unique, 0x25a00, 4) , (const, 0x10, 4), (unique, 0x25b00, 4) INT_SUB (unique, 0x25a00, 4) , (const, 0x10, 4), (register, 0x207, 1) INT_SLESS (unique, 0x25b00, 4) , (const, 0x0, 4), (register, 0x206, 1) INT_EQUAL (unique, 0x25b00, 4) , (const, 0x0, 4), (unique, 0x13480, 4) INT_AND (unique, 0x25b00, 4) , (const, 0xff, 4), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 4), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xcc00, 1) BOOL_NEGATE (register, 0x206, 1), --- CBRANCH (ram, 0x15abe3, 8) , (unique, 0xcc00, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe60, 8), (register, 0x0, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (const, 0x10a6fa, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x15abe3, 8), --- CALL (ram, 0x10a070, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe38, 8), (register, 0x10, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe60, 8), (register, 0x0, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (register, 0x10, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x15abfc, 8), --- CALL (ram, 0x109b40, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe60, 8), (register, 0x0, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_CARRY (register, 0x0, 8) , (const, 0x78, 8), (register, 0x20b, 1) INT_SCARRY (register, 0x0, 8) , (const, 0x78, 8), (register, 0x0, 8) INT_ADD (register, 0x0, 8) , (const, 0x78, 8), (register, 0x207, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x0, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x15ac0f, 8), --- CALL (ram, 0x109930, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (unique, 0x56380, 1) INT_AND (register, 0x0, 1) , (register, 0x0, 1), (register, 0x207, 1) INT_SLESS (unique, 0x56380, 1) , (const, 0x0, 1), (register, 0x206, 1) INT_EQUAL (unique, 0x56380, 1) , (const, 0x0, 1), (unique, 0x13480, 1) INT_AND (unique, 0x56380, 1) , (const, 0xff, 1), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 1), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- CBRANCH (ram, 0x15ac1a, 8) , (register, 0x206, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x18, 8) COPY (const, 0xffffffff, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- BRANCH (ram, 0x15ac23, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe38, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3200, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x18, 4) COPY (register, 0x0, 4), (register, 0x18, 8) INT_ZEXT (register, 0x18, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffe60, 8), (register, 0x0, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x15ac32, 8), --- CALL (ram, 0x109ac0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x0, 4) COPY (register, 0x18, 4), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x8, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x4f00, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8), (register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8), (register, 0x8, 8) INT_XOR (register, 0x8, 8) , (unique, 0xc300, 8), (register, 0x207, 1) INT_SLESS (register, 0x8, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x8, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x8, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- CBRANCH (ram, 0x15aca4, 8) , (register, 0x206, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- BRANCH (ram, 0x15ac9f, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x15aca4, 8), --- CALL (ram, 0x109e70, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_CARRY (register, 0x20, 8) , (const, 0x1d8, 8), (register, 0x20b, 1) INT_SCARRY (register, 0x20, 8) , (const, 0x1d8, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x1d8, 8), (register, 0x207, 1) INT_SLESS (register, 0x20, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x20, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x20, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3c380, 8) COPY (const, 0x0, 8), (unique, 0x3c380, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), (register, 0x18, 8) COPY (unique, 0x3c380, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3c380, 8) COPY (const, 0x0, 8), (unique, 0x3c380, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), (register, 0x28, 8) COPY (unique, 0x3c380, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "value", "assembly": ["PUSH RBP", "MOV RBP,RSP", "PUSH RBX", "SUB RSP,0x1d8", "MOV qword ptr [RBP + -0x1d8],RDI", "MOV EAX,ESI", "MOV dword ptr [RBP + -0x1e0],EDX", "MOV byte ptr [RBP + -0x1dc],AL", "MOV RAX,qword ptr FS:[0x28]", "MOV qword ptr [RBP + -0x18],RAX", "XOR EAX,EAX", "LEA RAX,[RBP + -0x1c8]", "MOV RDI,RAX", "CALL 0x0010a110", "MOVSX EDX,byte ptr [RBP + -0x1dc]", "LEA RCX,[RBP + -0x1c8]", "LEA RAX,[RBP + -0x1c0]", "MOV ESI,0x1", "MOV RDI,RAX", "CALL 0x00109ba0", "LEA RCX,[RBP + -0x1c0]", "LEA RAX,[RBP + -0x1a0]", "MOV EDX,0x8", "MOV RSI,RCX", "MOV RDI,RAX", "CALL 0x0010a080", "LEA RAX,[RBP + -0x1c0]", "MOV RDI,RAX", "CALL 0x00109920", "LEA RAX,[RBP + -0x1c8]", "MOV RDI,RAX", "CALL 0x00109e00", "CMP dword ptr [RBP + -0x1e0],0x8", "JNZ 0x0015abc4", "LEA RAX,[RBP + -0x1a0]", "LEA RSI,[0x10a726]", "MOV RDI,RAX", "CALL 0x0010a070", "JMP 0x0015abe3", "CMP dword ptr [RBP + -0x1e0],0x10", "JNZ 0x0015abe3", "LEA RAX,[RBP + -0x1a0]", "LEA RSI,[0x10a6fa]", "MOV RDI,RAX", "CALL 0x0010a070", "LEA RDX,[RBP + -0x1c8]", "LEA RAX,[RBP + -0x1a0]", "MOV RSI,RDX", "MOV RDI,RAX", "CALL 0x00109b40", "LEA RAX,[RBP + -0x1a0]", "ADD RAX,0x78", "MOV RDI,RAX", "CALL 0x00109930", "TEST AL,AL", "JZ 0x0015ac1a", "MOV EBX,0xffffffff", "JMP 0x0015ac23", "MOV RAX,qword ptr [RBP + -0x1c8]", "MOV EBX,EAX", "LEA RAX,[RBP + -0x1a0]", "MOV RDI,RAX", "CALL 0x00109ac0", "MOV EAX,EBX", "MOV RCX,qword ptr [RBP + -0x18]", "XOR RCX,qword ptr FS:[0x28]", "JZ 0x0015aca4", "JMP 0x0015ac9f", "CALL 0x00109e70", "ADD RSP,0x1d8", "POP RBX", "POP RBP", "RET"], "code": " std::vector<double> value(num_nz);\n REQUIRE(highs.getStandardFormLp(num_col, num_row, num_nz, offset, cost.data(),\n rhs.data(), start.data(), index.data(),\n value.data()) == HighsStatus::kOk);\n\n HighsLp standard_form_lp;\n standard_form_lp.num_col_ = num_col;\n standard_form_lp.num_row_ = num_row;\n standard_form_lp.offset_ = offset;\n standard_form_lp.col_cost_ = cost;\n standard_form_lp.col_lower_.assign(num_col, 0);\n standard_form_lp.col_upper_.assign(num_col, kHighsInf);\n standard_form_lp.row_lower_ = rhs;\n standard_form_lp.row_upper_ = rhs;\n standard_form_lp.a_matrix_.start_ = start;\n standard_form_lp.a_matrix_.index_ = index;\n standard_form_lp.a_matrix_.value_ = value;\n REQUIRE(highs.passModel(standard_form_lp) == HighsStatus::kOk);\n // highs.writeModel(\"\");\n REQUIRE(highs.run() == HighsStatus::kOk);\n REQUIRE(highs.getModelStatus() == HighsModelStatus::kOptimal);\n highs.writeSolution(\"\", kSolutionStylePretty);\n double objective_function_value =\n sense * highs.getInfo().objective_function_value;\n double objective_difference =\n std::fabs(objective_function_value - required_objective_function_value) /\n std::max(1.0, std::fabs(required_objective_function_value));\n REQUIRE(objective_difference < 1e-10);\n const bool look_at_presolved_lp = false;\n if (look_at_presolved_lp) {\n // Strange that presolve doesn't convert the constraints\n //\n // Ax-s = b; s >= 0 into Ax >= b\n REQUIRE(highs.passModel(standard_form_lp) == HighsStatus::kOk);\n REQUIRE(highs.presolve() == HighsStatus::kOk);\n HighsLp presolved_lp = highs.getPresolvedLp();\n REQUIRE(highs.passModel(presolved_lp) == HighsStatus::kOk);\n highs.writeModel(\"\");\n }\n", "authors": {"JAJHall": 1.0}, "leading_author": "JAJHall", "total_score": 1726.0, "unique": true}]}]}
|
datasets/conan/Imath.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/Inter-Component-Communication.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"commit_hash": "db1e30542cb7f667d4eba985d7405564921639b1", "data": [{"file": "/src/analysis/Inter-Component-Communication/examples/CommandLoop/main.cpp", "functions": [{"p_code_refined": [" --- CALL (ram, 0x1c2230, 8) , (unique, 0x100000a4, 8)", "(ram, 0x23afa0, 8) INDIRECT (ram, 0x23afa0, 8) , (const, 0x1c, 4)", "(unique, 0x100000a4, 8) PTRSUB (register, 0x38, 8) , (const, 0x0, 4)", "(unique, 0x3100, 8) PTRADD (ram, 0x23afa0, 8) , (const, 0x10, 8) , (const, 0x1, 8)", " --- STORE (const, 0x1b1, 4) , (unique, 0x1000008c, 8) , (unique, 0x100000ac, 8)", "(ram, 0x23afa0, 8) INDIRECT (ram, 0x23afa0, 8) , (const, 0x24, 4)", "(unique, 0x1000005c, 8) PTRSUB (register, 0x38, 8) , (const, 0x0, 8)", "(unique, 0x1000008c, 8) PTRSUB (unique, 0x1000005c, 8) , (const, 0x0, 8)", "(unique, 0x100000ac, 8) CAST (unique, 0x3100, 8)", "(unique, 0x3100, 8) PTRSUB (register, 0x38, 8) , (const, 0x8, 8)", "(register, 0x0, 8) CALL (ram, 0x1bb190, 8) , (register, 0x30, 8)", "(ram, 0x23afa0, 8) INDIRECT (ram, 0x23afa0, 8) , (const, 0x30, 4)", " --- CALL (ram, 0x1bc310, 8) , (unique, 0x3100, 8) , (register, 0x0, 8)", "(ram, 0x23afa0, 8) INDIRECT (ram, 0x23afa0, 8) , (const, 0x35, 4)", "(register, 0x0, 8) PTRSUB (register, 0x38, 8) , (const, 0x8, 8)", "(register, 0x0, 8) CALL (ram, 0x1beec0, 8) , (unique, 0x100000b4, 8)", "(ram, 0x23afa0, 8) INDIRECT (ram, 0x23afa0, 8) , (const, 0x45, 4)", "(unique, 0x100000b4, 8) CAST (register, 0x0, 8)", "(register, 0x0, 8) PTRSUB (register, 0x0, 8) , (const, 0x1c, 8)", " --- CALLOTHER (const, 0x11, 4)", "(unique, 0x5480, 4) LOAD (const, 0x1b1, 4) , (unique, 0x10000094, 8)", "(unique, 0xcd300, 4) INT_ADD (unique, 0x5480, 4) , (const, 0x1, 4)", " --- STORE (const, 0x1b1, 4) , (unique, 0x1000009c, 8) , (unique, 0xcd300, 4)", " --- CALLOTHER (const, 0x12, 4)", "(ram, 0x23afa0, 8) INDIRECT (ram, 0x23afa0, 8) , (const, 0x69, 4)", "(unique, 0x1000007c, 8) PTRSUB (register, 0x0, 8) , (const, 0x0, 8)", "(unique, 0x10000084, 8) PTRSUB (register, 0x0, 8) , (const, 0x0, 8)", "(unique, 0x10000094, 8) PTRSUB (unique, 0x1000007c, 8) , (const, 0x0, 8)", "(unique, 0x1000009c, 8) PTRSUB (unique, 0x10000084, 8) , (const, 0x0, 8)", " --- RETURN (const, 0x0, 8)", "(ram, 0x23afa0, 8) COPY (ram, 0x23afa0, 8)"], "raw": ["f30f1efa", "55", "4889e5", "53", "4883ec28", "48897dd8", "488975d0", "488b45d8", "4889c7", "e82ff8fdff", "488b0598850500", "488d5010", "488b45d8", "488910", "488b45d8", "488d5808", "488b45d0", "4889c7", "e86987fdff", "4889c6", "4889df", "e8de98fdff", "488b45d8", "4883c008", "4889c7", "e87ec4fdff", "4883c01c", "488945e8", "c745e001000000", "c745e404000000", "488b45e8", "8b55e0", "f00fc110", "90", "90", "4883c428", "5b", "5d", "c3"], "c_code": "\n/* DWARF original prototype: void Channel(Channel * this,\n shared_ptr<icc::Context<icc::_private::containers::ThreadSafeQueue<std::function<void()>_>_>_> *\n context) */\n\nvoid __thiscall\nicc::Context<icc::_private::containers::ThreadSafeQueue<std::function<void()>_>_>::Channel::Channel\n (Channel *this,\n shared_ptr<icc::Context<icc::_private::containers::ThreadSafeQueue<std::function<void()>_>_>_>\n *context)\n\n{\n type *__r;\n element_type *peVar1;\n shared_ptr<icc::Context<icc::_private::containers::ThreadSafeQueue<std::function<void()>_>_>_>\n *context_local;\n Channel *this_local;\n \n IContext::IChannel::IChannel(&this->super_IChannel);\n (this->super_IChannel)._vptr_IChannel = (_func_int_varargs **)(PTR_vtable_0023afa0 + 0x10);\n __r = std::\n move<std::shared_ptr<icc::Context<icc::_private::containers::ThreadSafeQueue<std::function<void()>_>_>_>&>\n (context);\n std::\n shared_ptr<icc::Context<icc::_private::containers::ThreadSafeQueue<std::function<void()>_>_>_>::\n shared_ptr(&this->context_,__r);\n peVar1 = std::\n __shared_ptr_access<icc::Context<icc::_private::containers::ThreadSafeQueue<std::function<void()>_>_>,_(__gnu_cxx::_Lock_policy)2,_false,_false>\n ::operator->((__shared_ptr_access<icc::Context<icc::_private::containers::ThreadSafeQueue<std::function<void()>_>_>,_(__gnu_cxx::_Lock_policy)2,_false,_false>\n *)&this->context_);\n LOCK();\n (peVar1->num_of_channels_).super___atomic_base<unsigned_int>._M_i =\n (peVar1->num_of_channels_).super___atomic_base<unsigned_int>._M_i + 1;\n UNLOCK();\n return;\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x18, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_LESS (register, 0x20, 8) , (const, 0x28, 8), (register, 0x20b, 1) INT_SBORROW (register, 0x20, 8) , (const, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x28, 8), (register, 0x207, 1) INT_SLESS (register, 0x20, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x20, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x20, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd8, 8), (unique, 0x5500, 8) COPY (register, 0x38, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd0, 8), (unique, 0x5500, 8) COPY (register, 0x30, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x1e2a01, 8), --- CALL (ram, 0x1c2230, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x0, 8) COPY (ram, 0x23afa0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x0, 8) , (const, 0x10, 8), (register, 0x10, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x5500, 8) COPY (register, 0x10, 8), --- STORE (const, 0x1b1, 4) , (register, 0x0, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x0, 8) , (const, 0x8, 8), (register, 0x18, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd0, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x1e2a27, 8), --- CALL (ram, 0x1bb190, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x18, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x1e2a32, 8), --- CALL (ram, 0x1bc310, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_CARRY (register, 0x0, 8) , (const, 0x8, 8), (register, 0x20b, 1) INT_SCARRY (register, 0x0, 8) , (const, 0x8, 8), (register, 0x0, 8) INT_ADD (register, 0x0, 8) , (const, 0x8, 8), (register, 0x207, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x0, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x1e2a42, 8), --- CALL (ram, 0x1beec0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_CARRY (register, 0x0, 8) , (const, 0x1c, 8), (register, 0x20b, 1) INT_SCARRY (register, 0x0, 8) , (const, 0x1c, 8), (register, 0x0, 8) INT_ADD (register, 0x0, 8) , (const, 0x1c, 8), (register, 0x207, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x0, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe0, 8), (unique, 0x5800, 4) COPY (const, 0x1, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5800, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe4, 8), (unique, 0x5800, 4) COPY (const, 0x4, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5800, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe0, 8), (unique, 0xc200, 4) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x10, 4) COPY (unique, 0xc200, 4), (register, 0x10, 8) INT_ZEXT (register, 0x10, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- CALLOTHER (const, 0x11, 4), (unique, 0x5480, 4) LOAD (const, 0x1b1, 4) , (register, 0x0, 8), (register, 0x200, 1) INT_CARRY (unique, 0x5480, 4) , (register, 0x10, 4), (unique, 0x5480, 4) LOAD (const, 0x1b1, 4) , (register, 0x0, 8), (register, 0x20b, 1) INT_SCARRY (unique, 0x5480, 4) , (register, 0x10, 4), (unique, 0x5480, 4) LOAD (const, 0x1b1, 4) , (register, 0x0, 8), (unique, 0xcd300, 4) INT_ADD (unique, 0x5480, 4) , (register, 0x10, 4), (unique, 0x5480, 4) LOAD (const, 0x1b1, 4) , (register, 0x0, 8), (register, 0x10, 4) COPY (unique, 0x5480, 4), (unique, 0x5480, 4) COPY (unique, 0xcd300, 4), --- STORE (const, 0x1b1, 4) , (register, 0x0, 8) , (unique, 0x5480, 4), (register, 0x207, 1) INT_SLESS (unique, 0xcd300, 4) , (const, 0x0, 4), (register, 0x206, 1) INT_EQUAL (unique, 0xcd300, 4) , (const, 0x0, 4), (unique, 0x13480, 4) INT_AND (unique, 0xcd300, 4) , (const, 0xff, 4), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 4), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1), --- CALLOTHER (const, 0x12, 4)])", "array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_CARRY (register, 0x20, 8) , (const, 0x28, 8), (register, 0x20b, 1) INT_SCARRY (register, 0x20, 8) , (const, 0x28, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x28, 8), (register, 0x207, 1) INT_SLESS (register, 0x20, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x20, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x20, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3c380, 8) COPY (const, 0x0, 8), (unique, 0x3c380, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), (register, 0x18, 8) COPY (unique, 0x3c380, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3c380, 8) COPY (const, 0x0, 8), (unique, 0x3c380, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), (register, 0x28, 8) COPY (unique, 0x3c380, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "Channel", "assembly": ["ENDBR64", "PUSH RBP", "MOV RBP,RSP", "PUSH RBX", "SUB RSP,0x28", "MOV qword ptr [RBP + -0x28],RDI", "MOV qword ptr [RBP + -0x30],RSI", "MOV RAX,qword ptr [RBP + -0x28]", "MOV RDI,RAX", "CALL 0x001c2230", "MOV RAX,qword ptr [0x0023afa0]", "LEA RDX,[RAX + 0x10]", "MOV RAX,qword ptr [RBP + -0x28]", "MOV qword ptr [RAX],RDX", "MOV RAX,qword ptr [RBP + -0x28]", "LEA RBX,[RAX + 0x8]", "MOV RAX,qword ptr [RBP + -0x30]", "MOV RDI,RAX", "CALL 0x001bb190", "MOV RSI,RAX", "MOV RDI,RBX", "CALL 0x001bc310", "MOV RAX,qword ptr [RBP + -0x28]", "ADD RAX,0x8", "MOV RDI,RAX", "CALL 0x001beec0", "ADD RAX,0x1c", "MOV qword ptr [RBP + -0x18],RAX", "MOV dword ptr [RBP + -0x20],0x1", "MOV dword ptr [RBP + -0x1c],0x4", "MOV RAX,qword ptr [RBP + -0x18]", "MOV EDX,dword ptr [RBP + -0x20]", "XADD.LOCK dword ptr [RAX],EDX", "NOP", "NOP", "ADD RSP,0x28", "POP RBX", "POP RBP", "RET"], "code": " explicit Channel(std::shared_ptr<Context> context)\n : context_{std::move(context)} {\n", "authors": {"redradist": 1.0}, "leading_author": "redradist", "total_score": 94.0, "unique": true}]}]}
|
datasets/conan/JWasm.json
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:ac82a470655719286f4070fe4f07164ab8e19ff6c3fba33a083c77cbed241cb2
|
| 3 |
+
size 31895093
|
datasets/conan/KTX-Software.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"commit_hash": "91ace88675ac59a97e55d0378a6602a9ae6b98bd", "data": [{"file": "/src/analysis/KTX-Software/tools/ktx/validate.cpp", "functions": [{"p_code_refined": ["(register, 0x206, 1) INT_NOTEQUAL (register, 0x0, 1) , (const, 0x0, 1)", " --- CBRANCH (ram, 0x104837, 1) , (register, 0x206, 1)", "(unique, 0x1000018f, 4) COPY (register, 0x1200, 4)", "(unique, 0x10000193, 4) COPY (register, 0x1220, 4)", "(unique, 0x10000197, 4) COPY (register, 0x1240, 4)", "(unique, 0x1000019b, 4) COPY (register, 0x1260, 4)", "(unique, 0x1000019f, 4) COPY (register, 0x1280, 4)", "(unique, 0x100001a3, 4) COPY (register, 0x12a0, 4)", "(unique, 0x100001a7, 4) COPY (register, 0x12c0, 4)", "(unique, 0x100001ab, 4) COPY (register, 0x12e0, 4)", "(unique, 0x100001af, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8)", "(unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8)", "(stack, 0xffffffffffffff78, 4) MULTIEQUAL (stack, 0xffffffffffffff78, 4) , (unique, 0x1000018f, 4)", "(stack, 0xffffffffffffff88, 4) MULTIEQUAL (stack, 0xffffffffffffff88, 4) , (unique, 0x10000193, 4)", "(stack, 0xffffffffffffff98, 4) MULTIEQUAL (stack, 0xffffffffffffff98, 4) , (unique, 0x10000197, 4)", "(stack, 0xffffffffffffffa8, 4) MULTIEQUAL (stack, 0xffffffffffffffa8, 4) , (unique, 0x1000019b, 4)", "(stack, 0xffffffffffffffb8, 4) MULTIEQUAL (stack, 0xffffffffffffffb8, 4) , (unique, 0x1000019f, 4)", "(stack, 0xffffffffffffffc8, 4) MULTIEQUAL (stack, 0xffffffffffffffc8, 4) , (unique, 0x100001a3, 4)", "(stack, 0xffffffffffffffd8, 4) MULTIEQUAL (stack, 0xffffffffffffffd8, 4) , (unique, 0x100001a7, 4)", "(stack, 0xffffffffffffffe8, 4) MULTIEQUAL (stack, 0xffffffffffffffe8, 4) , (unique, 0x100001ab, 4)", "(unique, 0x4f00, 8) CAST (unique, 0x100001af, 8)", "(stack, 0xffffffffffffff28, 4) COPY (const, 0x10, 4)", "(stack, 0xffffffffffffff2c, 4) COPY (const, 0x30, 4)", "(unique, 0x3100, 8) PTRSUB (register, 0x20, 8) , (const, 0x8, 8)", "(unique, 0x3200, 8) PTRSUB (register, 0x20, 8) , (const, 0xffffffffffffff48, 8)", "(register, 0x0, 8) PTRSUB (register, 0x38, 8) , (const, 0x8, 8)", "(register, 0x0, 8) CALL (ram, 0x103580, 8) , (unique, 0x100001b7, 8) , (unique, 0x100001bf, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x71, 4)", "(ram, 0x10d040, 8) INDIRECT (ram, 0x10d040, 8) , (const, 0x71, 4)", "(stack, 0xffffffffffffff28, 4) INDIRECT (stack, 0xffffffffffffff28, 4) , (const, 0x71, 4)", "(stack, 0xffffffffffffff2c, 4) INDIRECT (stack, 0xffffffffffffff2c, 4) , (const, 0x71, 4)", "(stack, 0xffffffffffffff30, 8) INDIRECT (unique, 0x3100, 8) , (const, 0x71, 4)", "(stack, 0xffffffffffffff38, 8) INDIRECT (unique, 0x3200, 8) , (const, 0x71, 4)", "(stack, 0xffffffffffffff58, 8) INDIRECT (unique, 0x1000016f, 8) , (const, 0x71, 4)", "(stack, 0xffffffffffffff60, 8) INDIRECT (unique, 0x10000177, 8) , (const, 0x71, 4)", "(stack, 0xffffffffffffff68, 8) INDIRECT (unique, 0x1000017f, 8) , (const, 0x71, 4)", "(stack, 0xffffffffffffff70, 8) INDIRECT (unique, 0x10000187, 8) , (const, 0x71, 4)", "(stack, 0xffffffffffffff78, 4) INDIRECT (stack, 0xffffffffffffff78, 4) , (const, 0x71, 4)", "(stack, 0xffffffffffffff88, 4) INDIRECT (stack, 0xffffffffffffff88, 4) , (const, 0x71, 4)", "(stack, 0xffffffffffffff98, 4) INDIRECT (stack, 0xffffffffffffff98, 4) , (const, 0x71, 4)", "(stack, 0xffffffffffffffa8, 4) INDIRECT (stack, 0xffffffffffffffa8, 4) , (const, 0x71, 4)", "(stack, 0xffffffffffffffb8, 4) INDIRECT (stack, 0xffffffffffffffb8, 4) , (const, 0x71, 4)", "(stack, 0xffffffffffffffc8, 4) INDIRECT (stack, 0xffffffffffffffc8, 4) , (const, 0x71, 4)", "(stack, 0xffffffffffffffd8, 4) INDIRECT (stack, 0xffffffffffffffd8, 4) , (const, 0x71, 4)", "(stack, 0xffffffffffffffe8, 4) INDIRECT (stack, 0xffffffffffffffe8, 4) , (const, 0x71, 4)", "(unique, 0x1000013f, 8) PTRSUB (const, 0x0, 8) , (const, 0x10d060, 8)", "(unique, 0x1000016f, 8) COPY (register, 0x10, 8)", "(unique, 0x10000177, 8) COPY (register, 0x8, 8)", "(unique, 0x1000017f, 8) COPY (register, 0x80, 8)", "(unique, 0x10000187, 8) COPY (register, 0x88, 8)", "(unique, 0x100001b7, 8) CAST (unique, 0x1000013f, 8)", "(unique, 0x100001bf, 8) CAST (register, 0x0, 8)", " --- CALL (ram, 0x1035b0, 8) , (register, 0x0, 8) , (unique, 0x1000012f, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x76, 4)", "(ram, 0x10d040, 8) INDIRECT (ram, 0x10d040, 8) , (const, 0x76, 4)", "(stack, 0xffffffffffffff28, 4) INDIRECT (stack, 0xffffffffffffff28, 4) , (const, 0x76, 4)", "(stack, 0xffffffffffffff2c, 4) INDIRECT (stack, 0xffffffffffffff2c, 4) , (const, 0x76, 4)", "(stack, 0xffffffffffffff30, 8) INDIRECT (stack, 0xffffffffffffff30, 8) , (const, 0x76, 4)", "(stack, 0xffffffffffffff38, 8) INDIRECT (stack, 0xffffffffffffff38, 8) , (const, 0x76, 4)", "(stack, 0xffffffffffffff58, 8) INDIRECT (stack, 0xffffffffffffff58, 8) , (const, 0x76, 4)", "(stack, 0xffffffffffffff60, 8) INDIRECT (stack, 0xffffffffffffff60, 8) , (const, 0x76, 4)", "(stack, 0xffffffffffffff68, 8) INDIRECT (stack, 0xffffffffffffff68, 8) , (const, 0x76, 4)", "(stack, 0xffffffffffffff70, 8) INDIRECT (stack, 0xffffffffffffff70, 8) , (const, 0x76, 4)", "(stack, 0xffffffffffffff78, 4) INDIRECT (stack, 0xffffffffffffff78, 4) , (const, 0x76, 4)", "(stack, 0xffffffffffffff88, 4) INDIRECT (stack, 0xffffffffffffff88, 4) , (const, 0x76, 4)", "(stack, 0xffffffffffffff98, 4) INDIRECT (stack, 0xffffffffffffff98, 4) , (const, 0x76, 4)", "(stack, 0xffffffffffffffa8, 4) INDIRECT (stack, 0xffffffffffffffa8, 4) , (const, 0x76, 4)", "(stack, 0xffffffffffffffb8, 4) INDIRECT (stack, 0xffffffffffffffb8, 4) , (const, 0x76, 4)", "(stack, 0xffffffffffffffc8, 4) INDIRECT (stack, 0xffffffffffffffc8, 4) , (const, 0x76, 4)", "(stack, 0xffffffffffffffd8, 4) INDIRECT (stack, 0xffffffffffffffd8, 4) , (const, 0x76, 4)", "(stack, 0xffffffffffffffe8, 4) INDIRECT (stack, 0xffffffffffffffe8, 4) , (const, 0x76, 4)", "(unique, 0x1000012f, 8) COPY (const, 0x1090ba, 8)", "(unique, 0x3200, 8) PTRSUB (register, 0x20, 8) , (const, 0xffffffffffffff28, 8)", " --- CALL (ram, 0x1036c0, 8) , (ram, 0x10d040, 8) , (register, 0x30, 8) , (unique, 0x3200, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x81, 4)", "(ram, 0x10d040, 8) INDIRECT (ram, 0x10d040, 8) , (const, 0x81, 4)", "(stack, 0xffffffffffffff28, 4) INDIRECT (stack, 0xffffffffffffff28, 4) , (const, 0x81, 4)", "(stack, 0xffffffffffffff2c, 4) INDIRECT (stack, 0xffffffffffffff2c, 4) , (const, 0x81, 4)", "(stack, 0xffffffffffffff30, 8) INDIRECT (stack, 0xffffffffffffff30, 8) , (const, 0x81, 4)", "(stack, 0xffffffffffffff38, 8) INDIRECT (stack, 0xffffffffffffff38, 8) , (const, 0x81, 4)", "(stack, 0xffffffffffffff58, 8) INDIRECT (stack, 0xffffffffffffff58, 8) , (const, 0x81, 4)", "(stack, 0xffffffffffffff60, 8) INDIRECT (stack, 0xffffffffffffff60, 8) , (const, 0x81, 4)", "(stack, 0xffffffffffffff68, 8) INDIRECT (stack, 0xffffffffffffff68, 8) , (const, 0x81, 4)", "(stack, 0xffffffffffffff70, 8) INDIRECT (stack, 0xffffffffffffff70, 8) , (const, 0x81, 4)", "(stack, 0xffffffffffffff78, 4) INDIRECT (stack, 0xffffffffffffff78, 4) , (const, 0x81, 4)", "(stack, 0xffffffffffffff88, 4) INDIRECT (stack, 0xffffffffffffff88, 4) , (const, 0x81, 4)", "(stack, 0xffffffffffffff98, 4) INDIRECT (stack, 0xffffffffffffff98, 4) , (const, 0x81, 4)", "(stack, 0xffffffffffffffa8, 4) INDIRECT (stack, 0xffffffffffffffa8, 4) , (const, 0x81, 4)", "(stack, 0xffffffffffffffb8, 4) INDIRECT (stack, 0xffffffffffffffb8, 4) , (const, 0x81, 4)", "(stack, 0xffffffffffffffc8, 4) INDIRECT (stack, 0xffffffffffffffc8, 4) , (const, 0x81, 4)", "(stack, 0xffffffffffffffd8, 4) INDIRECT (stack, 0xffffffffffffffd8, 4) , (const, 0x81, 4)", "(stack, 0xffffffffffffffe8, 4) INDIRECT (stack, 0xffffffffffffffe8, 4) , (const, 0x81, 4)", " --- CALL (ram, 0x1035b0, 8) , (unique, 0x100001c7, 8) , (unique, 0x10000137, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x86, 4)", "(ram, 0x10d040, 8) INDIRECT (ram, 0x10d040, 8) , (const, 0x86, 4)", "(stack, 0xffffffffffffff28, 4) INDIRECT (stack, 0xffffffffffffff28, 4) , (const, 0x86, 4)", "(stack, 0xffffffffffffff2c, 4) INDIRECT (stack, 0xffffffffffffff2c, 4) , (const, 0x86, 4)", "(stack, 0xffffffffffffff30, 8) INDIRECT (stack, 0xffffffffffffff30, 8) , (const, 0x86, 4)", "(stack, 0xffffffffffffff38, 8) INDIRECT (stack, 0xffffffffffffff38, 8) , (const, 0x86, 4)", "(stack, 0xffffffffffffff58, 8) INDIRECT (stack, 0xffffffffffffff58, 8) , (const, 0x86, 4)", "(stack, 0xffffffffffffff60, 8) INDIRECT (stack, 0xffffffffffffff60, 8) , (const, 0x86, 4)", "(stack, 0xffffffffffffff68, 8) INDIRECT (stack, 0xffffffffffffff68, 8) , (const, 0x86, 4)", "(stack, 0xffffffffffffff70, 8) INDIRECT (stack, 0xffffffffffffff70, 8) , (const, 0x86, 4)", "(stack, 0xffffffffffffff78, 4) INDIRECT (stack, 0xffffffffffffff78, 4) , (const, 0x86, 4)", "(stack, 0xffffffffffffff88, 4) INDIRECT (stack, 0xffffffffffffff88, 4) , (const, 0x86, 4)", "(stack, 0xffffffffffffff98, 4) INDIRECT (stack, 0xffffffffffffff98, 4) , (const, 0x86, 4)", "(stack, 0xffffffffffffffa8, 4) INDIRECT (stack, 0xffffffffffffffa8, 4) , (const, 0x86, 4)", "(stack, 0xffffffffffffffb8, 4) INDIRECT (stack, 0xffffffffffffffb8, 4) , (const, 0x86, 4)", "(stack, 0xffffffffffffffc8, 4) INDIRECT (stack, 0xffffffffffffffc8, 4) , (const, 0x86, 4)", "(stack, 0xffffffffffffffd8, 4) INDIRECT (stack, 0xffffffffffffffd8, 4) , (const, 0x86, 4)", "(stack, 0xffffffffffffffe8, 4) INDIRECT (stack, 0xffffffffffffffe8, 4) , (const, 0x86, 4)", "(unique, 0x10000137, 8) COPY (const, 0x1090bd, 8)", "(unique, 0x10000147, 8) PTRSUB (const, 0x0, 8) , (const, 0x10d060, 8)", "(unique, 0x100001c7, 8) CAST (unique, 0x10000147, 8)", "(unique, 0x100001cf, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8)", "(unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8)", "(register, 0x206, 1) INT_NOTEQUAL (unique, 0xc300, 8) , (unique, 0xc300, 8)", "(unique, 0x4f00, 8) CAST (unique, 0x100001cf, 8)", " --- CBRANCH (ram, 0x1048ea, 1) , (register, 0x206, 1)", " --- CALL (ram, 0x103640, 8)", " --- RETURN (const, 0x1, 4)", "(ram, 0x10d040, 8) INDIRECT (ram, 0x10d040, 8) , (const, 0x98, 4)", "(ram, 0x10d040, 8) COPY (ram, 0x10d040, 8)", "(stack, 0xffffffffffffff28, 4) INDIRECT (stack, 0xffffffffffffff28, 4) , (const, 0x98, 4)", "(stack, 0xffffffffffffff2c, 4) INDIRECT (stack, 0xffffffffffffff2c, 4) , (const, 0x98, 4)", "(stack, 0xffffffffffffff30, 8) INDIRECT (stack, 0xffffffffffffff30, 8) , (const, 0x98, 4)", "(stack, 0xffffffffffffff38, 8) INDIRECT (stack, 0xffffffffffffff38, 8) , (const, 0x98, 4)", "(stack, 0xffffffffffffff58, 8) INDIRECT (stack, 0xffffffffffffff58, 8) , (const, 0x98, 4)", "(stack, 0xffffffffffffff60, 8) INDIRECT (stack, 0xffffffffffffff60, 8) , (const, 0x98, 4)", "(stack, 0xffffffffffffff68, 8) INDIRECT (stack, 0xffffffffffffff68, 8) , (const, 0x98, 4)", "(stack, 0xffffffffffffff70, 8) INDIRECT (stack, 0xffffffffffffff70, 8) , (const, 0x98, 4)", "(stack, 0xffffffffffffff78, 4) INDIRECT (stack, 0xffffffffffffff78, 4) , (const, 0x98, 4)", "(stack, 0xffffffffffffff88, 4) INDIRECT (stack, 0xffffffffffffff88, 4) , (const, 0x98, 4)", "(stack, 0xffffffffffffff98, 4) INDIRECT (stack, 0xffffffffffffff98, 4) , (const, 0x98, 4)", "(stack, 0xffffffffffffffa8, 4) INDIRECT (stack, 0xffffffffffffffa8, 4) , (const, 0x98, 4)", "(stack, 0xffffffffffffffb8, 4) INDIRECT (stack, 0xffffffffffffffb8, 4) , (const, 0x98, 4)", "(stack, 0xffffffffffffffc8, 4) INDIRECT (stack, 0xffffffffffffffc8, 4) , (const, 0x98, 4)", "(stack, 0xffffffffffffffd8, 4) INDIRECT (stack, 0xffffffffffffffd8, 4) , (const, 0x98, 4)", "(stack, 0xffffffffffffffe8, 4) INDIRECT (stack, 0xffffffffffffffe8, 4) , (const, 0x98, 4)", " --- RETURN (const, 0x0, 8)", "(ram, 0x10d040, 8) COPY (ram, 0x10d040, 8)"], "raw": ["f30f1efa", "55", "4889e5", "4881ece0000000", "4889bd28ffffff", "4889b520ffffff", "48899560ffffff", "48898d68ffffff", "4c898570ffffff", "4c898d78ffffff", "84c0", "7420", "0f294580", "0f294d90", "0f2955a0", "0f295db0", "0f2965c0", "0f296dd0", "0f2975e0", "0f297df0", "64488b042528000000", "48898548ffffff", "31c0", "c78530ffffff10000000", "c78534ffffff30000000", "488d4510", "48898538ffffff", "488d8550ffffff", "48898540ffffff", "488b8528ffffff", "4883c008", "4889c6", "488d3dd5870000", "e8f0ecffff", "488d3523480000", "4889c7", "e811edffff", "488b059a870000", "488d9530ffffff", "488b8d20ffffff", "4889ce", "4889c7", "e801eeffff", "488d35f7470000", "488d3d93870000", "e8deecffff", "90", "488b8548ffffff", "644833042528000000", "7405", "e856edffff", "c9", "c3"], "c_code": "\n/* DWARF original prototype: void error(ktxApp * this, char * pFmt, ...) */\n\nvoid __thiscall ktxApp::error(ktxApp *this,char *pFmt,...)\n\n{\n long lVar1;\n char in_AL;\n basic_ostream *pbVar2;\n undefined8 in_RCX;\n undefined8 in_RDX;\n undefined8 in_R8;\n undefined8 in_R9;\n long in_FS_OFFSET;\n undefined4 in_XMM0_Da;\n undefined4 in_XMM1_Da;\n undefined4 in_XMM2_Da;\n undefined4 in_XMM3_Da;\n undefined4 in_XMM4_Da;\n undefined4 in_XMM5_Da;\n undefined4 in_XMM6_Da;\n undefined4 in_XMM7_Da;\n char *pFmt_local;\n ktxApp *this_local;\n va_list args;\n undefined local_b8 [16];\n undefined8 local_a8;\n undefined8 local_a0;\n undefined8 local_98;\n undefined8 local_90;\n undefined4 local_88;\n undefined4 local_78;\n undefined4 local_68;\n undefined4 local_58;\n undefined4 local_48;\n undefined4 local_38;\n undefined4 local_28;\n undefined4 local_18;\n \n if (in_AL != '\\0') {\n local_88 = in_XMM0_Da;\n local_78 = in_XMM1_Da;\n local_68 = in_XMM2_Da;\n local_58 = in_XMM3_Da;\n local_48 = in_XMM4_Da;\n local_38 = in_XMM5_Da;\n local_28 = in_XMM6_Da;\n local_18 = in_XMM7_Da;\n }\n lVar1 = *(long *)(in_FS_OFFSET + 0x28);\n args[0].gp_offset = 0x10;\n args[0].fp_offset = 0x30;\n args[0].overflow_arg_area = &stack0x00000008;\n args[0].reg_save_area = local_b8;\n local_a8 = in_RDX;\n local_a0 = in_RCX;\n local_98 = in_R8;\n local_90 = in_R9;\n pbVar2 = std::operator<<((basic_ostream *)std::cerr,(basic_string *)&this->name);\n std::operator<<(pbVar2,\": \");\n vfprintf(stderr,pFmt,args);\n std::operator<<((basic_ostream *)std::cerr,\"\\n\");\n if (lVar1 != *(long *)(in_FS_OFFSET + 0x28)) {\n /* WARNING: Subroutine does not return */\n __stack_chk_fail();\n }\n return;\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_LESS (register, 0x20, 8) , (const, 0xe0, 8), (register, 0x20b, 1) INT_SBORROW (register, 0x20, 8) , (const, 0xe0, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0xe0, 8), (register, 0x207, 1) INT_SLESS (register, 0x20, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x20, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x20, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff28, 8), (unique, 0x5500, 8) COPY (register, 0x38, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff20, 8), (unique, 0x5500, 8) COPY (register, 0x30, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff60, 8), (unique, 0x5500, 8) COPY (register, 0x10, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff68, 8), (unique, 0x5500, 8) COPY (register, 0x8, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff70, 8), (unique, 0x5500, 8) COPY (register, 0x80, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff78, 8), (unique, 0x5500, 8) COPY (register, 0x88, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (unique, 0x56380, 1) INT_AND (register, 0x0, 1) , (register, 0x0, 1), (register, 0x207, 1) INT_SLESS (unique, 0x56380, 1) , (const, 0x0, 1), (register, 0x206, 1) INT_EQUAL (unique, 0x56380, 1) , (const, 0x0, 1), (unique, 0x13480, 1) INT_AND (unique, 0x56380, 1) , (const, 0xff, 1), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 1), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- CBRANCH (ram, 0x104837, 8) , (register, 0x206, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff80, 8), (unique, 0x5580, 16) COPY (register, 0x1200, 16), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5580, 16)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff90, 8), (unique, 0x5580, 16) COPY (register, 0x1220, 16), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5580, 16)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffa0, 8), (unique, 0x5580, 16) COPY (register, 0x1240, 16), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5580, 16)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffb0, 8), (unique, 0x5580, 16) COPY (register, 0x1260, 16), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5580, 16)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffc0, 8), (unique, 0x5580, 16) COPY (register, 0x1280, 16), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5580, 16)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd0, 8), (unique, 0x5580, 16) COPY (register, 0x12a0, 16), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5580, 16)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe0, 8), (unique, 0x5580, 16) COPY (register, 0x12c0, 16), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5580, 16)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0x5580, 16) COPY (register, 0x12e0, 16), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5580, 16)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x4f00, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff48, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (register, 0x0, 4) INT_XOR (register, 0x0, 4) , (register, 0x0, 4), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4), (register, 0x207, 1) INT_SLESS (register, 0x0, 4) , (const, 0x0, 4), (register, 0x206, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x0, 4), (unique, 0x13480, 4) INT_AND (register, 0x0, 4) , (const, 0xff, 4), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 4), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff30, 8), (unique, 0x5800, 4) COPY (const, 0x10, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5800, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff34, 8), (unique, 0x5800, 4) COPY (const, 0x30, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5800, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0x10, 8), (register, 0x0, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff38, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff50, 8), (register, 0x0, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff40, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3200, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff28, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3200, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_CARRY (register, 0x0, 8) , (const, 0x8, 8), (register, 0x20b, 1) INT_SCARRY (register, 0x0, 8) , (const, 0x8, 8), (register, 0x0, 8) INT_ADD (register, 0x0, 8) , (const, 0x8, 8), (register, 0x207, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x0, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (const, 0x10d060, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x104890, 8), --- CALL (ram, 0x103580, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (const, 0x1090ba, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x10489f, 8), --- CALL (ram, 0x1035b0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x0, 8) COPY (ram, 0x10d040, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff30, 8), (register, 0x10, 8) COPY (unique, 0x3200, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff20, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3200, 8), (register, 0x8, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (register, 0x8, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x1048bf, 8), --- CALL (ram, 0x1036c0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (const, 0x1090bd, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (const, 0x10d060, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x1048d2, 8), --- CALL (ram, 0x1035b0, 8)])", "array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3200, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffff48, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3200, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x4f00, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8), (register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8), (register, 0x0, 8) INT_XOR (register, 0x0, 8) , (unique, 0xc300, 8), (register, 0x207, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x0, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- CBRANCH (ram, 0x1048ea, 8) , (register, 0x206, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x1048ea, 8), --- CALL (ram, 0x103640, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) COPY (register, 0x28, 8), (register, 0x28, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "error", "assembly": ["ENDBR64", "PUSH RBP", "MOV RBP,RSP", "SUB RSP,0xe0", "MOV qword ptr [RBP + -0xd8],RDI", "MOV qword ptr [RBP + -0xe0],RSI", "MOV qword ptr [RBP + -0xa0],RDX", "MOV qword ptr [RBP + -0x98],RCX", "MOV qword ptr [RBP + -0x90],R8", "MOV qword ptr [RBP + -0x88],R9", "TEST AL,AL", "JZ 0x00104837", "MOVAPS xmmword ptr [RBP + -0x80],XMM0", "MOVAPS xmmword ptr [RBP + -0x70],XMM1", "MOVAPS xmmword ptr [RBP + -0x60],XMM2", "MOVAPS xmmword ptr [RBP + -0x50],XMM3", "MOVAPS xmmword ptr [RBP + -0x40],XMM4", "MOVAPS xmmword ptr [RBP + -0x30],XMM5", "MOVAPS xmmword ptr [RBP + -0x20],XMM6", "MOVAPS xmmword ptr [RBP + -0x10],XMM7", "MOV RAX,qword ptr FS:[0x28]", "MOV qword ptr [RBP + -0xb8],RAX", "XOR EAX,EAX", "MOV dword ptr [RBP + -0xd0],0x10", "MOV dword ptr [RBP + -0xcc],0x30", "LEA RAX,[RBP + 0x10]", "MOV qword ptr [RBP + -0xc8],RAX", "LEA RAX,[RBP + -0xb0]", "MOV qword ptr [RBP + -0xc0],RAX", "MOV RAX,qword ptr [RBP + -0xd8]", "ADD RAX,0x8", "MOV RSI,RAX", "LEA RDI,[0x10d060]", "CALL 0x00103580", "LEA RSI,[0x1090ba]", "MOV RDI,RAX", "CALL 0x001035b0", "MOV RAX,qword ptr [0x0010d040]", "LEA RDX,[RBP + -0xd0]", "MOV RCX,qword ptr [RBP + -0xe0]", "MOV RSI,RCX", "MOV RDI,RAX", "CALL 0x001036c0", "LEA RSI,[0x1090bd]", "LEA RDI,[0x10d060]", "CALL 0x001035b0", "NOP", "MOV RAX,qword ptr [RBP + -0xb8]", "XOR RAX,qword ptr FS:[0x28]", "JZ 0x001048ea", "CALL 0x00103640", "LEAVE", "RET"], "code": " void error(const IssueError& issue, Args&&... args) {\n ++numError;\n returnCode = +rc::INVALID_FILE;\n callback(ValidationReport{issue.type, issue.id, std::string{issue.message}, fmt::format(issue.detailsFmt, std::forward<Args>(args)...)});\n }\n", "authors": {"Cs\u00e1sz\u00e1r M\u00e1ty\u00e1s": 1.0}, "leading_author": "Cs\u00e1sz\u00e1r M\u00e1ty\u00e1s", "total_score": 265.0, "unique": true}]}]}
|
datasets/conan/LASzip.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/LUrlParser.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"commit_hash": "ff4c603ee5e9d356c853295719e355a81106b7f6", "data": [{"file": "/src/analysis/LUrlParser/LUrlParser.cpp", "functions": [{"p_code_refined": ["(unique, 0x100000af, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8)", "(unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8)", "(unique, 0x4f00, 8) CAST (unique, 0x100000af, 8)", "(unique, 0x100000b7, 8) CALL (ram, 0x1022d0, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x2c, 4)", "(register, 0x0, 8) CAST (unique, 0x100000b7, 8)", "(unique, 0x100000bf, 8) CALL (ram, 0x102410, 8) , (register, 0x38, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x36, 4)", "(stack, 0xffffffffffffffd8, 8) INDIRECT (register, 0x0, 8) , (const, 0x36, 4)", "(register, 0x0, 8) CAST (unique, 0x100000bf, 8)", "(register, 0x110, 8) MULTIEQUAL (register, 0x110, 8) , (register, 0x110, 8)", "(stack, 0xffffffffffffffd8, 8) MULTIEQUAL (stack, 0xffffffffffffffd8, 8) , (stack, 0xffffffffffffffd8, 8)", "(stack, 0xffffffffffffffe0, 8) MULTIEQUAL (register, 0x0, 8) , (stack, 0xffffffffffffffe0, 8)", "(unique, 0x3100, 8) PTRSUB (register, 0x20, 8) , (const, 0xffffffffffffffe0, 8)", "(unique, 0x3100, 8) PTRSUB (register, 0x20, 8) , (const, 0xffffffffffffffd8, 8)", "(register, 0x0, 1) CALL (ram, 0x102230, 8) , (unique, 0x3100, 8) , (unique, 0x3100, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x42, 4)", "(stack, 0xffffffffffffffd8, 8) INDIRECT (stack, 0xffffffffffffffd8, 8) , (const, 0x42, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x42, 4)", "(register, 0x206, 1) BOOL_NEGATE (register, 0x0, 1)", " --- CBRANCH (ram, 0x102580, 1) , (register, 0x206, 1)", "(unique, 0x3100, 8) PTRSUB (register, 0x20, 8) , (const, 0xffffffffffffffd8, 8)", "(register, 0x0, 8) CALL (ram, 0x1023e0, 8) , (unique, 0x3100, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x52, 4)", "(stack, 0xffffffffffffffd8, 8) INDIRECT (stack, 0xffffffffffffffd8, 8) , (const, 0x52, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x52, 4)", "(unique, 0xc080, 1) LOAD (const, 0x1b1, 4) , (register, 0x0, 8)", "(register, 0x0, 4) INT_SEXT (unique, 0xc080, 1)", "(register, 0x0, 4) CALL (ram, 0x1023d0, 8) , (register, 0x0, 4)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x61, 4)", "(stack, 0xffffffffffffffd8, 8) INDIRECT (stack, 0xffffffffffffffd8, 8) , (const, 0x61, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x61, 4)", "(register, 0x206, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x0, 4)", " --- CBRANCH (ram, 0x102572, 1) , (register, 0x206, 1)", "(register, 0x206, 1) INT_NOTEQUAL (unique, 0xc080, 1) , (const, 0x2b, 1)", " --- CBRANCH (ram, 0x102572, 1) , (register, 0x206, 1)", "(register, 0x206, 1) INT_NOTEQUAL (unique, 0xc080, 1) , (const, 0x2d, 1)", " --- CBRANCH (ram, 0x102572, 1) , (register, 0x206, 1)", "(register, 0x206, 1) INT_NOTEQUAL (unique, 0xc080, 1) , (const, 0x2e, 1)", " --- CBRANCH (ram, 0x102572, 1) , (register, 0x206, 1)", "(register, 0x0, 1) COPY (const, 0x0, 1)", " --- BRANCH (ram, 0x102585, 1)", "(unique, 0x3100, 8) PTRSUB (register, 0x20, 8) , (const, 0xffffffffffffffd8, 8)", " --- CALL (ram, 0x1022b0, 8) , (unique, 0x3100, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0xb5, 4)", "(stack, 0xffffffffffffffd8, 8) INDIRECT (stack, 0xffffffffffffffd8, 8) , (const, 0xb5, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0xb5, 4)", " --- BRANCH (ram, 0x102521, 1)", "(register, 0x0, 1) COPY (const, 0x1, 1)", "(register, 0x110, 8) MULTIEQUAL (register, 0x110, 8) , (register, 0x110, 8)", "(register, 0x0, 1) MULTIEQUAL (register, 0x0, 1) , (register, 0x0, 1)", "(stack, 0xffffffffffffffd8, 8) MULTIEQUAL (stack, 0xffffffffffffffd8, 8) , (stack, 0xffffffffffffffd8, 8)", "(stack, 0xffffffffffffffe0, 8) MULTIEQUAL (stack, 0xffffffffffffffe0, 8) , (stack, 0xffffffffffffffe0, 8)", "(unique, 0x100000c7, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8)", "(unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8)", "(register, 0x206, 1) INT_NOTEQUAL (unique, 0xc300, 8) , (unique, 0xc300, 8)", "(unique, 0x4f00, 8) CAST (unique, 0x100000c7, 8)", " --- CBRANCH (ram, 0x102599, 1) , (register, 0x206, 1)", " --- CALL (ram, 0x102330, 8)", " --- RETURN (const, 0x1, 4)", "(stack, 0xffffffffffffffd8, 8) INDIRECT (stack, 0xffffffffffffffd8, 8) , (const, 0xa7, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0xa7, 4)", " --- RETURN (const, 0x0, 8) , (register, 0x0, 1)", "(register, 0x0, 1) COPY (register, 0x0, 1)"], "raw": ["f30f1efa", "55", "4889e5", "4883ec40", "48897dc8", "64488b042528000000", "488945f8", "31c0", "488b45c8", "488945f0", "488b45f0", "4889c7", "e8c3fdffff", "488945e0", "488b45f0", "4889c7", "e8f3feffff", "488945e8", "488d55e8", "488d45e0", "4889d6", "4889c7", "e8fcfcffff", "84c0", "7448", "488d45e0", "4889c7", "e89cfeffff", "0fb600", "8845df", "0fbe45df", "89c7", "e87bfeffff", "85c0", "7519", "807ddf2b", "7413", "807ddf2d", "740d", "807ddf2e", "7407", "b800000000", "eb13", "488d45e0", "4889c7", "e832fdffff", "eba1", "b801000000", "488b4df8", "6448330c2528000000", "7405", "e897fdffff", "c9", "c3"], "c_code": "\nbool anon_unknown.conflictc526::isSchemeValid(string *schemeName)\n\n{\n char cVar1;\n long lVar2;\n bool bVar3;\n int iVar4;\n reference pcVar5;\n long in_FS_OFFSET;\n string *schemeName_local;\n char c;\n const_iterator __for_begin;\n const_iterator __for_end;\n basic_string<char,_std::char_traits<char>,_std::allocator<char>_> *__for_range;\n \n lVar2 = *(long *)(in_FS_OFFSET + 0x28);\n __for_begin._M_current =\n (char *)std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin()\n ;\n __for_end._M_current = (char *)FUN_00102410(schemeName);\n do {\n bVar3 = __gnu_cxx::operator!=<char_const*,_std::__cxx11::basic_string<char>_>\n (&__for_begin,&__for_end);\n if (!bVar3) {\n bVar3 = true;\nLAB_00102585:\n if (lVar2 != *(long *)(in_FS_OFFSET + 0x28)) {\n /* WARNING: Subroutine does not return */\n __stack_chk_fail();\n }\n return bVar3;\n }\n pcVar5 = __gnu_cxx::\n __normal_iterator<char_const*,_std::__cxx11::basic_string<char,_std::char_traits<char>,_std::allocator<char>_>_>\n ::operator*(&__for_begin);\n cVar1 = *pcVar5;\n iVar4 = isalpha((int)cVar1);\n if ((((iVar4 == 0) && (cVar1 != '+')) && (cVar1 != '-')) && (cVar1 != '.')) {\n bVar3 = false;\n goto LAB_00102585;\n }\n __gnu_cxx::\n __normal_iterator<char_const*,_std::__cxx11::basic_string<char,_std::char_traits<char>,_std::allocator<char>_>_>\n ::operator++(&__for_begin);\n } while( true );\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_LESS (register, 0x20, 8) , (const, 0x40, 8), (register, 0x20b, 1) INT_SBORROW (register, 0x20, 8) , (const, 0x40, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x40, 8), (register, 0x207, 1) INT_SLESS (register, 0x20, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x20, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x20, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffc8, 8), (unique, 0x5500, 8) COPY (register, 0x38, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x4f00, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (register, 0x0, 4) INT_XOR (register, 0x0, 4) , (register, 0x0, 4), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4), (register, 0x207, 1) INT_SLESS (register, 0x0, 4) , (const, 0x0, 4), (register, 0x206, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x0, 4), (unique, 0x13480, 4) INT_AND (register, 0x0, 4) , (const, 0xff, 4), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 4), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffc8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x10250d, 8), --- CALL (ram, 0x1022d0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe0, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x10251d, 8), --- CALL (ram, 0x102410, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (register, 0x10, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe0, 8), (register, 0x0, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (register, 0x10, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x102534, 8), --- CALL (ram, 0x102230, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (unique, 0x56380, 1) INT_AND (register, 0x0, 1) , (register, 0x0, 1), (register, 0x207, 1) INT_SLESS (unique, 0x56380, 1) , (const, 0x0, 1), (register, 0x206, 1) INT_EQUAL (unique, 0x56380, 1) , (const, 0x0, 1), (unique, 0x13480, 1) INT_AND (unique, 0x56380, 1) , (const, 0xff, 1), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 1), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- CBRANCH (ram, 0x102580, 8) , (register, 0x206, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe0, 8), (register, 0x0, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x102544, 8), --- CALL (ram, 0x1023e0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xc080, 1) LOAD (const, 0x1b1, 4) , (register, 0x0, 8), (register, 0x0, 4) INT_ZEXT (unique, 0xc080, 1), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffdf, 8), (unique, 0x5380, 1) COPY (register, 0x0, 1), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5380, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffdf, 8), (unique, 0xc080, 1) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 4) INT_SEXT (unique, 0xc080, 1), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 4) COPY (register, 0x0, 4), (register, 0x38, 8) INT_ZEXT (register, 0x38, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x102555, 8), --- CALL (ram, 0x1023d0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (unique, 0x56580, 4) INT_AND (register, 0x0, 4) , (register, 0x0, 4), (register, 0x207, 1) INT_SLESS (unique, 0x56580, 4) , (const, 0x0, 4), (register, 0x206, 1) INT_EQUAL (unique, 0x56580, 4) , (const, 0x0, 4), (unique, 0x13480, 4) INT_AND (unique, 0x56580, 4) , (const, 0xff, 4), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 4), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xcc00, 1) BOOL_NEGATE (register, 0x206, 1), --- CBRANCH (ram, 0x102572, 8) , (unique, 0xcc00, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffdf, 8), (unique, 0xc080, 1) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (unique, 0x25280, 1) COPY (unique, 0xc080, 1), (register, 0x200, 1) INT_LESS (unique, 0x25280, 1) , (const, 0x2b, 1), (register, 0x20b, 1) INT_SBORROW (unique, 0x25280, 1) , (const, 0x2b, 1), (unique, 0x25380, 1) INT_SUB (unique, 0x25280, 1) , (const, 0x2b, 1), (register, 0x207, 1) INT_SLESS (unique, 0x25380, 1) , (const, 0x0, 1), (register, 0x206, 1) INT_EQUAL (unique, 0x25380, 1) , (const, 0x0, 1), (unique, 0x13480, 1) INT_AND (unique, 0x25380, 1) , (const, 0xff, 1), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 1), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- CBRANCH (ram, 0x102572, 8) , (register, 0x206, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffdf, 8), (unique, 0xc080, 1) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (unique, 0x25280, 1) COPY (unique, 0xc080, 1), (register, 0x200, 1) INT_LESS (unique, 0x25280, 1) , (const, 0x2d, 1), (register, 0x20b, 1) INT_SBORROW (unique, 0x25280, 1) , (const, 0x2d, 1), (unique, 0x25380, 1) INT_SUB (unique, 0x25280, 1) , (const, 0x2d, 1), (register, 0x207, 1) INT_SLESS (unique, 0x25380, 1) , (const, 0x0, 1), (register, 0x206, 1) INT_EQUAL (unique, 0x25380, 1) , (const, 0x0, 1), (unique, 0x13480, 1) INT_AND (unique, 0x25380, 1) , (const, 0xff, 1), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 1), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- CBRANCH (ram, 0x102572, 8) , (register, 0x206, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffdf, 8), (unique, 0xc080, 1) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (unique, 0x25280, 1) COPY (unique, 0xc080, 1), (register, 0x200, 1) INT_LESS (unique, 0x25280, 1) , (const, 0x2e, 1), (register, 0x20b, 1) INT_SBORROW (unique, 0x25280, 1) , (const, 0x2e, 1), (unique, 0x25380, 1) INT_SUB (unique, 0x25280, 1) , (const, 0x2e, 1), (register, 0x207, 1) INT_SLESS (unique, 0x25380, 1) , (const, 0x0, 1), (register, 0x206, 1) INT_EQUAL (unique, 0x25380, 1) , (const, 0x0, 1), (unique, 0x13480, 1) INT_AND (unique, 0x25380, 1) , (const, 0xff, 1), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 1), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- CBRANCH (ram, 0x102572, 8) , (register, 0x206, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x0, 8) COPY (const, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- BRANCH (ram, 0x102585, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe0, 8), (register, 0x0, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x10257e, 8), --- CALL (ram, 0x1022b0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- BRANCH (ram, 0x102521, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x0, 8) COPY (const, 0x1, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x8, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x4f00, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8), (register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8), (register, 0x8, 8) INT_XOR (register, 0x8, 8) , (unique, 0xc300, 8), (register, 0x207, 1) INT_SLESS (register, 0x8, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x8, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x8, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- CBRANCH (ram, 0x102599, 8) , (register, 0x206, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x102599, 8), --- CALL (ram, 0x102330, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) COPY (register, 0x28, 8), (register, 0x28, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "isSchemeValid", "assembly": ["ENDBR64", "PUSH RBP", "MOV RBP,RSP", "SUB RSP,0x40", "MOV qword ptr [RBP + -0x38],RDI", "MOV RAX,qword ptr FS:[0x28]", "MOV qword ptr [RBP + -0x8],RAX", "XOR EAX,EAX", "MOV RAX,qword ptr [RBP + -0x38]", "MOV qword ptr [RBP + -0x10],RAX", "MOV RAX,qword ptr [RBP + -0x10]", "MOV RDI,RAX", "CALL 0x001022d0", "MOV qword ptr [RBP + -0x20],RAX", "MOV RAX,qword ptr [RBP + -0x10]", "MOV RDI,RAX", "CALL 0x00102410", "MOV qword ptr [RBP + -0x18],RAX", "LEA RDX,[RBP + -0x18]", "LEA RAX,[RBP + -0x20]", "MOV RSI,RDX", "MOV RDI,RAX", "CALL 0x00102230", "TEST AL,AL", "JZ 0x00102580", "LEA RAX,[RBP + -0x20]", "MOV RDI,RAX", "CALL 0x001023e0", "MOVZX EAX,byte ptr [RAX]", "MOV byte ptr [RBP + -0x21],AL", "MOVSX EAX,byte ptr [RBP + -0x21]", "MOV EDI,EAX", "CALL 0x001023d0", "TEST EAX,EAX", "JNZ 0x00102572", "CMP byte ptr [RBP + -0x21],0x2b", "JZ 0x00102572", "CMP byte ptr [RBP + -0x21],0x2d", "JZ 0x00102572", "CMP byte ptr [RBP + -0x21],0x2e", "JZ 0x00102572", "MOV EAX,0x0", "JMP 0x00102585", "LEA RAX,[RBP + -0x20]", "MOV RDI,RAX", "CALL 0x001022b0", "JMP 0x00102521", "MOV EAX,0x1", "MOV RCX,qword ptr [RBP + -0x8]", "XOR RCX,qword ptr FS:[0x28]", "JZ 0x00102599", "CALL 0x00102330", "LEAVE", "RET"], "code": "\tbool isSchemeValid(const std::string& schemeName)\n\t{\n\t\tfor (auto c : schemeName)\n\t\t{\n\t\t\tif (!isalpha(c) && c != '+' && c != '-' && c != '.') return false;\n\t\t}\n\n\t\treturn true;\n\t}\n", "authors": {"Sergey Kosarevsky": 1.0}, "leading_author": "Sergey Kosarevsky", "total_score": 168.0, "unique": true}]}]}
|
datasets/conan/LibRaw.json
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:268f43cae4e7b0162b94a016837be569d8740565d17ebcd9c9a11f82c9ce2e04
|
| 3 |
+
size 18733361
|
datasets/conan/LightPcapNg.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/Little-CMS.json
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:92685742ee5fe50e74212c6ecc9f33d00c079831bd5d0f9d48bfe982303e8239
|
| 3 |
+
size 33952928
|
datasets/conan/METIS.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/MikkTSpace.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/OpenCL-ICD-Loader.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/OpenColorIO.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"commit_hash": "2831d2547d133b326c6e9a09726ceeb7fe46f997", "data": [{"file": "/src/analysis/OpenColorIO/src/OpenColorIO/CPUInfo.cpp", "functions": [{"p_code_refined": ["(register, 0x0, 8) INT_SEXT (register, 0x604, 4)", "(register, 0x0, 8) INT_LEFT (register, 0x0, 8) , (const, 0x20, 4)", "(register, 0x0, 8) INT_SEXT (register, 0x600, 4)", "(register, 0x0, 8) INT_OR (register, 0x0, 8) , (register, 0x0, 8)", " --- RETURN (const, 0x0, 8) , (register, 0x0, 8)"], "raw": ["55", "4889e5", "c745f400000000", "c745f800000000", "c745fc00000000", "8b45f4", "89c1", "0f01d0", "8945f8", "8955fc", "8b45fc", "4898", "48c1e020", "4889c2", "8b45f8", "4898", "4809d0", "5d", "c3"], "c_code": "\n/* WARNING: Unknown calling convention */\n\nint64_t OpenColorIO_v2_4::anon_unknown_1::xgetbv(void)\n\n{\n int in_XCR0;\n int in_register_00000604;\n int index;\n int eax;\n int edx;\n \n return (long)in_XCR0 | (long)in_register_00000604 << 0x20;\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff4, 8), (unique, 0x5800, 4) COPY (const, 0x0, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5800, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0x5800, 4) COPY (const, 0x0, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5800, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffffc, 8), (unique, 0x5800, 4) COPY (const, 0x0, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5800, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff4, 8), (unique, 0xc200, 4) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 4) COPY (unique, 0xc200, 4), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x8, 4) COPY (register, 0x0, 4), (register, 0x8, 8) INT_ZEXT (register, 0x8, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x58580, 8) INT_RIGHT (register, 0x600, 8) , (const, 0x20, 4), (register, 0x10, 4) SUBPIECE (unique, 0x58580, 8) , (const, 0x0, 4), (register, 0x0, 4) COPY (register, 0x600, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0x5480, 4) COPY (register, 0x0, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5480, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffffc, 8), (unique, 0x5480, 4) COPY (register, 0x10, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5480, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffffc, 8), (unique, 0xc200, 4) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 4) COPY (unique, 0xc200, 4), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x0, 8) INT_SEXT (register, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x50c80, 4) INT_AND (const, 0x20, 4) , (const, 0x3f, 4), (unique, 0x50d00, 8) COPY (register, 0x0, 8), (register, 0x0, 8) INT_LEFT (register, 0x0, 8) , (unique, 0x50c80, 4), (unique, 0x15880, 1) INT_NOTEQUAL (unique, 0x50c80, 4) , (const, 0x0, 4), (unique, 0x15900, 4) INT_SUB (unique, 0x50c80, 4) , (const, 0x1, 4), (unique, 0x15980, 8) INT_LEFT (unique, 0x50d00, 8) , (unique, 0x15900, 4), (unique, 0x15a80, 1) INT_SLESS (unique, 0x15980, 8) , (const, 0x0, 8), (unique, 0x15b00, 1) BOOL_NEGATE (unique, 0x15880, 1), (unique, 0x15b80, 1) INT_AND (unique, 0x15b00, 1) , (register, 0x200, 1), (unique, 0x15c00, 1) INT_AND (unique, 0x15880, 1) , (unique, 0x15a80, 1), (register, 0x200, 1) INT_OR (unique, 0x15b80, 1) , (unique, 0x15c00, 1), (unique, 0x15d80, 1) INT_EQUAL (unique, 0x50c80, 4) , (const, 0x1, 4), (unique, 0x15e00, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x15f00, 1) INT_XOR (register, 0x200, 1) , (unique, 0x15e00, 1), (unique, 0x15f80, 1) BOOL_NEGATE (unique, 0x15d80, 1), (unique, 0x16000, 1) INT_AND (unique, 0x15f80, 1) , (register, 0x20b, 1), (unique, 0x16080, 1) INT_AND (unique, 0x15d80, 1) , (unique, 0x15f00, 1), (register, 0x20b, 1) INT_OR (unique, 0x16000, 1) , (unique, 0x16080, 1), (unique, 0x13700, 1) INT_NOTEQUAL (unique, 0x50c80, 4) , (const, 0x0, 4), (unique, 0x13800, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13880, 1) BOOL_NEGATE (unique, 0x13700, 1), (unique, 0x13900, 1) INT_AND (unique, 0x13880, 1) , (register, 0x207, 1), (unique, 0x13980, 1) INT_AND (unique, 0x13700, 1) , (unique, 0x13800, 1), (register, 0x207, 1) INT_OR (unique, 0x13900, 1) , (unique, 0x13980, 1), (unique, 0x13b00, 1) INT_EQUAL (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13b80, 1) BOOL_NEGATE (unique, 0x13700, 1), (unique, 0x13c00, 1) INT_AND (unique, 0x13b80, 1) , (register, 0x206, 1), (unique, 0x13c80, 1) INT_AND (unique, 0x13700, 1) , (unique, 0x13b00, 1), (register, 0x206, 1) INT_OR (unique, 0x13c00, 1) , (unique, 0x13c80, 1), (unique, 0x13d80, 8) INT_AND (register, 0x0, 8) , (const, 0xff, 8), (unique, 0x13e00, 1) POPCOUNT (unique, 0x13d80, 8), (unique, 0x13e80, 1) INT_AND (unique, 0x13e00, 1) , (const, 0x1, 1), (unique, 0x13f80, 1) INT_EQUAL (unique, 0x13e80, 1) , (const, 0x0, 1), (unique, 0x14000, 1) BOOL_NEGATE (unique, 0x13700, 1), (unique, 0x14080, 1) INT_AND (unique, 0x14000, 1) , (register, 0x202, 1), (unique, 0x14100, 1) INT_AND (unique, 0x13700, 1) , (unique, 0x13f80, 1), (register, 0x202, 1) INT_OR (unique, 0x14080, 1) , (unique, 0x14100, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x10, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0xc200, 4) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 4) COPY (unique, 0xc200, 4), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x0, 8) INT_SEXT (register, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (register, 0x0, 8) INT_OR (register, 0x0, 8) , (register, 0x10, 8), (register, 0x207, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x0, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3c380, 8) COPY (const, 0x0, 8), (unique, 0x3c380, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), (register, 0x28, 8) COPY (unique, 0x3c380, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "xgetbv", "assembly": ["PUSH RBP", "MOV RBP,RSP", "MOV dword ptr [RBP + -0xc],0x0", "MOV dword ptr [RBP + -0x8],0x0", "MOV dword ptr [RBP + -0x4],0x0", "MOV EAX,dword ptr [RBP + -0xc]", "MOV ECX,EAX", "XGETBV", "MOV dword ptr [RBP + -0x8],EAX", "MOV dword ptr [RBP + -0x4],EDX", "MOV EAX,dword ptr [RBP + -0x4]", "CDQE", "SHL RAX,0x20", "MOV RDX,RAX", "MOV EAX,dword ptr [RBP + -0x8]", "CDQE", "OR RAX,RDX", "POP RBP", "RET"], "code": "static inline int64_t xgetbv()\n{\n int index = 0;\n#if _MSC_VER\n return _xgetbv(index);\n#else\n int eax = 0;\n int edx = 0;\n __asm__ volatile (\".byte 0x0f, 0x01, 0xd0\" : \"=a\"(eax), \"=d\"(edx) : \"c\" (index));\n return (int64_t)edx << 32 | (int64_t)eax;\n#endif\n}\n", "authors": {"Mark Reid": 1.0}, "leading_author": "Mark Reid", "total_score": 262.0, "unique": true}, {"p_code_refined": ["(unique, 0x3100, 8) PTRADD (register, 0x30, 8) , (const, 0x1, 8) , (const, 0x4, 8)", "(unique, 0x3100, 8) PTRADD (register, 0x30, 8) , (const, 0x2, 8) , (const, 0x4, 8)", "(unique, 0x3100, 8) PTRADD (register, 0x30, 8) , (const, 0x3, 8) , (const, 0x4, 8)", "(unique, 0x27980, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x0, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27980, 1)", "(unique, 0x27a00, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x1, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27a00, 1)", "(unique, 0x27a80, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x2, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27a80, 1)", "(unique, 0x27b00, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x3, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27b00, 1)", "(unique, 0x27b80, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x4, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27b80, 1)", "(unique, 0x27c00, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x5, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27c00, 1)", "(unique, 0x27c80, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x6, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27c80, 1)", "(unique, 0x27d00, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x7, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27d00, 1)", "(unique, 0x27d80, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x9, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27d80, 1)", "(unique, 0x27e00, 1) INT_EQUAL (register, 0x38, 4) , (const, 0xa, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27e00, 1)", "(unique, 0x27e80, 1) INT_EQUAL (register, 0x38, 4) , (const, 0xb, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27e80, 1)", "(unique, 0x27f00, 1) INT_EQUAL (register, 0x38, 4) , (const, 0xd, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27f00, 1)", "(unique, 0x27f80, 1) INT_EQUAL (register, 0x38, 4) , (const, 0xf, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x27f80, 1)", "(unique, 0x28000, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x80000002, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x28000, 1)", "(unique, 0x28080, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x80000003, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x28080, 1)", "(unique, 0x28100, 1) INT_EQUAL (register, 0x38, 4) , (const, 0x80000004, 4)", " --- CBRANCH (const, 0x21, 1) , (unique, 0x28100, 1)", "(unique, 0x100000b8, 8) CALLOTHER (const, 0x2c, 4) , (register, 0x38, 4)", " --- BRANCH (const, 0x21, 1)", "(unique, 0x10000038, 8) CALLOTHER (const, 0x2d, 4) , (const, 0x0, 4)", " --- BRANCH (const, 0x1f, 1)", "(unique, 0x10000040, 8) CALLOTHER (const, 0x2e, 4) , (const, 0x1, 4)", " --- BRANCH (const, 0x1d, 1)", "(unique, 0x10000048, 8) CALLOTHER (const, 0x2f, 4) , (const, 0x2, 4)", " --- BRANCH (const, 0x1b, 1)", "(unique, 0x10000050, 8) CALLOTHER (const, 0x30, 4) , (const, 0x3, 4)", " --- BRANCH (const, 0x19, 1)", "(unique, 0x10000058, 8) CALLOTHER (const, 0x31, 4) , (const, 0x4, 4)", " --- BRANCH (const, 0x17, 1)", "(unique, 0x10000060, 8) CALLOTHER (const, 0x32, 4) , (const, 0x5, 4)", " --- BRANCH (const, 0x15, 1)", "(unique, 0x10000068, 8) CALLOTHER (const, 0x33, 4) , (const, 0x6, 4)", " --- BRANCH (const, 0x13, 1)", "(unique, 0x10000070, 8) CALLOTHER (const, 0x34, 4) , (const, 0x7, 4)", " --- BRANCH (const, 0x11, 1)", "(unique, 0x10000078, 8) CALLOTHER (const, 0x35, 4) , (const, 0x9, 4)", " --- BRANCH (const, 0xf, 1)", "(unique, 0x10000080, 8) CALLOTHER (const, 0x36, 4) , (const, 0xa, 4)", " --- BRANCH (const, 0xd, 1)", "(unique, 0x10000088, 8) CALLOTHER (const, 0x37, 4) , (const, 0xb, 4)", " --- BRANCH (const, 0xb, 1)", "(unique, 0x10000090, 8) CALLOTHER (const, 0x38, 4) , (const, 0xd, 4)", " --- BRANCH (const, 0x9, 1)", "(unique, 0x10000098, 8) CALLOTHER (const, 0x39, 4) , (const, 0xf, 4)", " --- BRANCH (const, 0x7, 1)", "(unique, 0x100000a0, 8) CALLOTHER (const, 0x3a, 4) , (const, 0x80000002, 4)", " --- BRANCH (const, 0x5, 1)", "(unique, 0x100000a8, 8) CALLOTHER (const, 0x3b, 4) , (const, 0x80000003, 4)", " --- BRANCH (const, 0x3, 1)", "(unique, 0x100000b0, 8) CALLOTHER (const, 0x3c, 4) , (const, 0x80000004, 4)", " --- BRANCH (const, 0x1, 1)", "(unique, 0x28a00, 4) LOAD (const, 0x1b1, 4) , (unique, 0x27900, 8)", "(unique, 0x28b80, 4) LOAD (const, 0x1b1, 4) , (unique, 0x28b00, 8)", "(unique, 0x28d00, 4) LOAD (const, 0x1b1, 4) , (unique, 0x28c80, 8)", "(unique, 0x28e80, 4) LOAD (const, 0x1b1, 4) , (unique, 0x28e00, 8)", "(unique, 0x27900, 8) MULTIEQUAL (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8) , (unique, 0x27900, 8)", "(unique, 0x28b00, 8) PTRADD (unique, 0x27900, 8) , (const, 0x1, 8) , (const, 0x4, 8)", "(unique, 0x28c80, 8) PTRADD (unique, 0x27900, 8) , (const, 0x2, 8) , (const, 0x4, 8)", "(unique, 0x28e00, 8) PTRADD (unique, 0x27900, 8) , (const, 0x3, 8) , (const, 0x4, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000038, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000040, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000048, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000050, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000058, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000060, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000068, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000070, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000078, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000080, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000088, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000090, 8)", "(unique, 0x27900, 8) CAST (unique, 0x10000098, 8)", "(unique, 0x27900, 8) CAST (unique, 0x100000a0, 8)", "(unique, 0x27900, 8) CAST (unique, 0x100000a8, 8)", "(unique, 0x27900, 8) CAST (unique, 0x100000b0, 8)", "(unique, 0x27900, 8) CAST (unique, 0x100000b8, 8)", " --- STORE (const, 0x1b1, 4) , (register, 0x30, 8) , (unique, 0x28a00, 4)", " --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x28b80, 4)", " --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x28e80, 4)", " --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x28d00, 4)", " --- RETURN (const, 0x0, 8)"], "raw": ["55", "4889e5", "897dfc", "488975f0", "488b45f0", "4c8d5004", "488b45f0", "4c8d4808", "488b45f0", "4c8d400c", "8b45fc", "ba00000000", "89d1", "4889de", "0fa2", "4887de", "488b7df0", "8907", "418932", "418909", "418910", "90", "5d", "c3"], "c_code": "\nvoid OpenColorIO_v2_4::anon_unknown_1::cpuid(int index,int *data)\n\n{\n int *piVar1;\n int iVar2;\n int iVar3;\n int iVar4;\n int *data_local;\n int index_local;\n \n if (index == 0) {\n piVar1 = (int *)cpuid_basic_info(0);\n }\n else if (index == 1) {\n piVar1 = (int *)cpuid_Version_info(1);\n }\n else if (index == 2) {\n piVar1 = (int *)cpuid_cache_tlb_info(2);\n }\n else if (index == 3) {\n piVar1 = (int *)cpuid_serial_info(3);\n }\n else if (index == 4) {\n piVar1 = (int *)cpuid_Deterministic_Cache_Parameters_info(4);\n }\n else if (index == 5) {\n piVar1 = (int *)cpuid_MONITOR_MWAIT_Features_info(5);\n }\n else if (index == 6) {\n piVar1 = (int *)cpuid_Thermal_Power_Management_info(6);\n }\n else if (index == 7) {\n piVar1 = (int *)cpuid_Extended_Feature_Enumeration_info(7);\n }\n else if (index == 9) {\n piVar1 = (int *)cpuid_Direct_Cache_Access_info(9);\n }\n else if (index == 10) {\n piVar1 = (int *)cpuid_Architectural_Performance_Monitoring_info(10);\n }\n else if (index == 0xb) {\n piVar1 = (int *)cpuid_Extended_Topology_info(0xb);\n }\n else if (index == 0xd) {\n piVar1 = (int *)cpuid_Processor_Extended_States_info(0xd);\n }\n else if (index == 0xf) {\n piVar1 = (int *)cpuid_Quality_of_Service_info(0xf);\n }\n else if (index == -0x7ffffffe) {\n piVar1 = (int *)cpuid_brand_part1_info(0x80000002);\n }\n else if (index == -0x7ffffffd) {\n piVar1 = (int *)cpuid_brand_part2_info(0x80000003);\n }\n else if (index == -0x7ffffffc) {\n piVar1 = (int *)cpuid_brand_part3_info(0x80000004);\n }\n else {\n piVar1 = (int *)cpuid(index);\n }\n iVar2 = piVar1[1];\n iVar3 = piVar1[2];\n iVar4 = piVar1[3];\n *data = *piVar1;\n data[1] = iVar2;\n data[2] = iVar4;\n data[3] = iVar3;\n return;\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffffc, 8), (unique, 0x5480, 4) COPY (register, 0x38, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5480, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0x5500, 8) COPY (register, 0x30, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x0, 8) , (const, 0x4, 8), (register, 0x90, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x0, 8) , (const, 0x8, 8), (register, 0x88, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x0, 8) , (const, 0xc, 8), (register, 0x80, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffffc, 8), (unique, 0xc200, 4) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 4) COPY (unique, 0xc200, 4), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x10, 8) COPY (const, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x8, 4) COPY (register, 0x10, 4), (register, 0x8, 8) INT_ZEXT (register, 0x8, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (register, 0x18, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x27900, 8) COPY (const, 0x0, 8), (unique, 0x27980, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x0, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27980, 1), (unique, 0x27a00, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x1, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27a00, 1), (unique, 0x27a80, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x2, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27a80, 1), (unique, 0x27b00, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x3, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27b00, 1), (unique, 0x27b80, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x4, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27b80, 1), (unique, 0x27c00, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x5, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27c00, 1), (unique, 0x27c80, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x6, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27c80, 1), (unique, 0x27d00, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x7, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27d00, 1), (unique, 0x27d80, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x9, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27d80, 1), (unique, 0x27e00, 1) INT_EQUAL (register, 0x0, 4) , (const, 0xa, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27e00, 1), (unique, 0x27e80, 1) INT_EQUAL (register, 0x0, 4) , (const, 0xb, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27e80, 1), (unique, 0x27f00, 1) INT_EQUAL (register, 0x0, 4) , (const, 0xd, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27f00, 1), (unique, 0x27f80, 1) INT_EQUAL (register, 0x0, 4) , (const, 0xf, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x27f80, 1), (unique, 0x28000, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x80000002, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x28000, 1), (unique, 0x28080, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x80000003, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x28080, 1), (unique, 0x28100, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x80000004, 4), --- CBRANCH (const, 0x21, 4) , (unique, 0x28100, 1), (unique, 0x27900, 8) CALLOTHER (const, 0x2c, 4) , (register, 0x0, 4), --- BRANCH (const, 0x21, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x2d, 4) , (register, 0x0, 4), --- BRANCH (const, 0x1f, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x2e, 4) , (register, 0x0, 4), --- BRANCH (const, 0x1d, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x2f, 4) , (register, 0x0, 4), --- BRANCH (const, 0x1b, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x30, 4) , (register, 0x0, 4), --- BRANCH (const, 0x19, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x31, 4) , (register, 0x0, 4), --- BRANCH (const, 0x17, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x32, 4) , (register, 0x0, 4), --- BRANCH (const, 0x15, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x33, 4) , (register, 0x0, 4), --- BRANCH (const, 0x13, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x34, 4) , (register, 0x0, 4), --- BRANCH (const, 0x11, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x35, 4) , (register, 0x0, 4), --- BRANCH (const, 0xf, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x36, 4) , (register, 0x0, 4), --- BRANCH (const, 0xd, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x37, 4) , (register, 0x0, 4), --- BRANCH (const, 0xb, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x38, 4) , (register, 0x0, 4), --- BRANCH (const, 0x9, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x39, 4) , (register, 0x0, 4), --- BRANCH (const, 0x7, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x3a, 4) , (register, 0x0, 4), --- BRANCH (const, 0x5, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x3b, 4) , (register, 0x0, 4), --- BRANCH (const, 0x3, 4), (unique, 0x27900, 8) CALLOTHER (const, 0x3c, 4) , (register, 0x0, 4), --- BRANCH (const, 0x1, 4), (unique, 0x28a00, 4) LOAD (const, 0x1b1, 8) , (unique, 0x27900, 8), (register, 0x0, 8) INT_ZEXT (unique, 0x28a00, 4), (unique, 0x28b00, 8) INT_ADD (unique, 0x27900, 8) , (const, 0x4, 8), (unique, 0x28b80, 4) LOAD (const, 0x1b1, 8) , (unique, 0x28b00, 8), (register, 0x18, 8) INT_ZEXT (unique, 0x28b80, 4), (unique, 0x28c80, 8) INT_ADD (unique, 0x27900, 8) , (const, 0x8, 8), (unique, 0x28d00, 4) LOAD (const, 0x1b1, 8) , (unique, 0x28c80, 8), (register, 0x10, 8) INT_ZEXT (unique, 0x28d00, 4), (unique, 0x28e00, 8) INT_ADD (unique, 0x27900, 8) , (const, 0xc, 8), (unique, 0x28e80, 4) LOAD (const, 0x1b1, 8) , (unique, 0x28e00, 8), (register, 0x8, 8) INT_ZEXT (unique, 0x28e80, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x57500, 8) COPY (register, 0x30, 8), (register, 0x30, 8) COPY (register, 0x18, 8), (register, 0x18, 8) COPY (unique, 0x57500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x38, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x5480, 4) COPY (register, 0x0, 4), --- STORE (const, 0x1b1, 4) , (register, 0x38, 8) , (unique, 0x5480, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x5480, 4) COPY (register, 0x30, 4), --- STORE (const, 0x1b1, 4) , (register, 0x90, 8) , (unique, 0x5480, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x5480, 4) COPY (register, 0x8, 4), --- STORE (const, 0x1b1, 4) , (register, 0x88, 8) , (unique, 0x5480, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x5480, 4) COPY (register, 0x10, 4), --- STORE (const, 0x1b1, 4) , (register, 0x80, 8) , (unique, 0x5480, 4)])", "array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3c380, 8) COPY (const, 0x0, 8), (unique, 0x3c380, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), (register, 0x28, 8) COPY (unique, 0x3c380, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "cpuid", "assembly": ["PUSH RBP", "MOV RBP,RSP", "MOV dword ptr [RBP + -0x4],EDI", "MOV qword ptr [RBP + -0x10],RSI", "MOV RAX,qword ptr [RBP + -0x10]", "LEA R10,[RAX + 0x4]", "MOV RAX,qword ptr [RBP + -0x10]", "LEA R9,[RAX + 0x8]", "MOV RAX,qword ptr [RBP + -0x10]", "LEA R8,[RAX + 0xc]", "MOV EAX,dword ptr [RBP + -0x4]", "MOV EDX,0x0", "MOV ECX,EDX", "MOV RSI,RBX", "CPUID", "XCHG RSI,RBX", "MOV RDI,qword ptr [RBP + -0x10]", "MOV dword ptr [RDI],EAX", "MOV dword ptr [R10],ESI", "MOV dword ptr [R9],ECX", "MOV dword ptr [R8],EDX", "NOP", "POP RBP", "RET"], "code": "static inline void cpuid(int index, int *data)\n{\n#if _MSC_VER\n __cpuid(data, index);\n#elif OCIO_ARCH_X86_32\n __asm__ volatile (\n \"mov %%ebx, %%esi \\n\\t\"\n \"cpuid \\n\\t\"\n \"xchg %%ebx, %%esi\"\n : \"=a\" (data[0]), \"=S\" (data[1]), \"=c\" (data[2]), \"=d\" (data[3])\n : \"0\" (index), \"2\"(0));\n#else\n __asm__ volatile (\n \"mov %%rbx, %%rsi \\n\\t\"\n \"cpuid \\n\\t\"\n \"xchg %%rbx, %%rsi\"\n : \"=a\" (data[0]), \"=S\" (data[1]), \"=c\" (data[2]), \"=d\" (data[3])\n : \"0\" (index), \"2\"(0));\n#endif\n}\n", "authors": {"Mark Reid": 1.0}, "leading_author": "Mark Reid", "total_score": 562.0, "unique": true}]}]}
|
datasets/conan/OpenFBX.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/OpenJPH.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/OpenSubdiv.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/OpenXLSX.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/PDF-Writer.json
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:dec2db38ae26ef4d8da499c284a618fcb00ae6dd01d6fa585f1383a749890ec1
|
| 3 |
+
size 188208179
|
datasets/conan/PDFGen.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/PROJ.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"commit_hash": "0a407325fbb5bf42407a7dc5d4f948be9707e302", "data": [{"file": "/src/analysis/PROJ/src/4D_api.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_coord(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_coord", "assembly": [], "code": "PJ_COORD proj_coord(double x, double y, double z, double t) {\n PJ_COORD res;\n res.v[0] = x;\n res.v[1] = y;\n res.v[2] = z;\n res.v[3] = t;\n return res;\n}\n", "authors": {"Thomas Knudsen": 1.0}, "leading_author": "Thomas Knudsen", "total_score": 162.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_angular_input(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_angular_input", "assembly": [], "code": "int proj_angular_input(PJ *P, enum PJ_DIRECTION dir) {\n /******************************************************************************\n Returns 1 if the operator P expects angular input coordinates when\n operating in direction dir, 0 otherwise.\n dir: {PJ_FWD, PJ_INV}\n ******************************************************************************/\n if (PJ_FWD == dir)\n return pj_left(P) == PJ_IO_UNITS_RADIANS;\n return pj_right(P) == PJ_IO_UNITS_RADIANS;\n}\n", "authors": {"Even Rouault reformatting bot": 0.14255765199161424, "Kristian Evers": 0.18658280922431866, "Thomas Knudsen": 0.6708595387840671}, "leading_author": "Thomas Knudsen", "total_score": 477.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_angular_output(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_angular_output", "assembly": [], "code": "int proj_angular_output(PJ *P, enum PJ_DIRECTION dir) {\n /******************************************************************************\n Returns 1 if the operator P provides angular output coordinates when\n operating in direction dir, 0 otherwise.\n dir: {PJ_FWD, PJ_INV}\n ******************************************************************************/\n return proj_angular_input(P, opposite_direction(dir));\n}\n", "authors": {"Even Rouault reformatting bot": 0.04275534441805225, "Kristian Evers": 0.6199524940617577, "Thomas Knudsen": 0.33729216152019004}, "leading_author": "Kristian Evers", "total_score": 421.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_degree_output(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_degree_output", "assembly": [], "code": "int proj_degree_output(PJ *P, enum PJ_DIRECTION dir) {\n /******************************************************************************\n Returns 1 if the operator P provides degree output coordinates when\n operating in direction dir, 0 otherwise.\n dir: {PJ_FWD, PJ_INV}\n ******************************************************************************/\n return proj_degree_input(P, opposite_direction(dir));\n}\n", "authors": {"Even Rouault reformatting bot": 0.03827751196172249, "Thomas Knudsen": 0.5765550239234449, "Kristian Evers": 0.3373205741626794, "Even Rouault": 0.04784688995215311}, "leading_author": "Thomas Knudsen", "total_score": 418.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_trans(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_trans", "assembly": [], "code": "PJ_COORD proj_trans(PJ *P, PJ_DIRECTION direction, PJ_COORD coord) {\n /***************************************************************************************\n Apply the transformation P to the coordinate coord, preferring the 4D\n interfaces if available.\n\n See also pj_approx_2D_trans and pj_approx_3D_trans in pj_internal.c, which\n work similarly, but prefers the 2D resp. 3D interfaces if available.\n ***************************************************************************************/\n if (nullptr == P || direction == PJ_IDENT)\n return coord;\n if (P->inverted)\n direction = opposite_direction(direction);\n\n if (P->iso_obj != nullptr && !P->iso_obj_is_coordinate_operation) {\n pj_log(P->ctx, PJ_LOG_ERROR, \"Object is not a coordinate operation\");\n proj_errno_set(P, PROJ_ERR_INVALID_OP_ILLEGAL_ARG_VALUE);\n return proj_coord_error();\n }\n\n if (!P->alternativeCoordinateOperations.empty()) {\n constexpr int N_MAX_RETRY = 2;\n int iExcluded[N_MAX_RETRY] = {-1, -1};\n\n bool skipNonInstantiable = P->skipNonInstantiable &&\n !P->warnIfBestTransformationNotAvailable &&\n !P->errorIfBestTransformationNotAvailable;\n const int nOperations =\n static_cast<int>(P->alternativeCoordinateOperations.size());\n\n // We may need several attempts. For example the point at\n // long=-111.5 lat=45.26 falls into the bounding box of the Canadian\n // ntv2_0.gsb grid, except that it is not in any of the subgrids, being\n // in the US. We thus need another retry that will select the conus\n // grid.\n for (int iRetry = 0; iRetry <= N_MAX_RETRY; iRetry++) {\n // Do a first pass and select the operations that match the area of\n // use and has the best accuracy.\n int iBest = pj_get_suggested_operation(\n P->ctx, P->alternativeCoordinateOperations, iExcluded,\n skipNonInstantiable, direction, coord);\n if (iBest < 0) {\n break;\n }\n if (iRetry > 0) {\n const int oldErrno = proj_errno_reset(P);\n if (proj_log_level(P->ctx, PJ_LOG_TELL) >= PJ_LOG_DEBUG) {\n pj_log(P->ctx, PJ_LOG_DEBUG,\n proj_context_errno_string(P->ctx, oldErrno));\n }\n pj_log(P->ctx, PJ_LOG_DEBUG,\n \"Did not result in valid result. \"\n \"Attempting a retry with another operation.\");\n }\n\n const auto &alt = P->alternativeCoordinateOperations[iBest];\n if (P->iCurCoordOp != iBest) {\n if (proj_log_level(P->ctx, PJ_LOG_TELL) >= PJ_LOG_DEBUG) {\n std::string msg(\"Using coordinate operation \");\n msg += alt.name;\n pj_log(P->ctx, PJ_LOG_DEBUG, msg.c_str());\n }\n P->iCurCoordOp = iBest;\n }\n PJ_COORD res = coord;\n if (alt.pj->hasCoordinateEpoch)\n coord.xyzt.t = alt.pj->coordinateEpoch;\n if (direction == PJ_FWD)\n pj_fwd4d(res, alt.pj);\n else\n pj_inv4d(res, alt.pj);\n if (proj_errno(alt.pj) == PROJ_ERR_OTHER_NETWORK_ERROR) {\n return proj_coord_error();\n }\n if (res.xyzt.x != HUGE_VAL) {\n return res;\n } else if (P->errorIfBestTransformationNotAvailable ||\n P->warnIfBestTransformationNotAvailable) {\n warnAboutMissingGrid(alt.pj);\n if (P->errorIfBestTransformationNotAvailable) {\n proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_NO_OPERATION);\n return res;\n }\n P->warnIfBestTransformationNotAvailable = false;\n skipNonInstantiable = true;\n }\n if (iRetry == N_MAX_RETRY) {\n break;\n }\n iExcluded[iRetry] = iBest;\n }\n\n // In case we did not find an operation whose area of use is compatible\n // with the input coordinate, then goes through again the list, and\n // use the first operation that does not require grids.\n NS_PROJ::io::DatabaseContextPtr dbContext;\n try {\n if (P->ctx->cpp_context) {\n dbContext =\n P->ctx->cpp_context->getDatabaseContext().as_nullable();\n }\n } catch (const std::exception &) {\n }\n for (int i = 0; i < nOperations; i++) {\n const auto &alt = P->alternativeCoordinateOperations[i];\n auto coordOperation =\n dynamic_cast<NS_PROJ::operation::CoordinateOperation *>(\n alt.pj->iso_obj.get());\n if (coordOperation) {\n if (coordOperation->gridsNeeded(dbContext, true).empty()) {\n if (P->iCurCoordOp != i) {\n if (proj_log_level(P->ctx, PJ_LOG_TELL) >=\n PJ_LOG_DEBUG) {\n std::string msg(\"Using coordinate operation \");\n msg += alt.name;\n msg += \" as a fallback due to lack of more \"\n \"appropriate operations\";\n pj_log(P->ctx, PJ_LOG_DEBUG, msg.c_str());\n }\n P->iCurCoordOp = i;\n }\n if (direction == PJ_FWD) {\n pj_fwd4d(coord, alt.pj);\n } else {\n pj_inv4d(coord, alt.pj);\n }\n return coord;\n }\n }\n }\n\n proj_errno_set(P, PROJ_ERR_COORD_TRANSFM_NO_OPERATION);\n return proj_coord_error();\n }\n\n P->iCurCoordOp =\n 0; // dummy value, to be used by proj_trans_get_last_used_operation()\n if (P->hasCoordinateEpoch)\n coord.xyzt.t = P->coordinateEpoch;\n if (coord_has_nans(coord))\n coord.v[0] = coord.v[1] = coord.v[2] = coord.v[3] =\n std::numeric_limits<double>::quiet_NaN();\n else if (direction == PJ_FWD)\n pj_fwd4d(coord, P);\n else\n pj_inv4d(coord, P);\n return coord;\n}\n", "authors": {"Even Rouault": 0.7608486017357763, "Even Rouault reformatting bot": 0.203150112504018, "David Hoese": 0.02812600450016072, "Kristian Evers": 0.0006428801028608164, "Thomas Knudsen": 0.007232401157184185}, "leading_author": "Even Rouault", "total_score": 6222.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_torad(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_torad", "assembly": [], "code": "double proj_torad(double angle_in_degrees) {\n return PJ_TORAD(angle_in_degrees);\n}\n", "authors": {"Thomas Knudsen": 0.5421686746987951, "Even Rouault reformatting bot": 0.4578313253012048}, "leading_author": "Thomas Knudsen", "total_score": 83.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_todeg(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_todeg", "assembly": [], "code": "double proj_todeg(double angle_in_radians) {\n return PJ_TODEG(angle_in_radians);\n}\n", "authors": {"Even Rouault reformatting bot": 1.0}, "leading_author": "Even Rouault reformatting bot", "total_score": 83.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_create_argv(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_create_argv", "assembly": [], "code": "PJ *proj_create_argv(PJ_CONTEXT *ctx, int argc, char **argv) {\n /**************************************************************************************\n Create a new PJ object in the context ctx, using the given definition\n argument array argv. If ctx==0, the default context is used, if\n definition==0, or invalid, a null-pointer is returned. The definition\n arguments may use '+' as argument start indicator, as in {\"+proj=utm\",\n \"+zone=32\"}, or leave it out, as in {\"proj=utm\", \"zone=32\"}.\n **************************************************************************************/\n\n if (nullptr == ctx)\n ctx = pj_get_default_ctx();\n if (nullptr == argv) {\n proj_context_errno_set(ctx, PROJ_ERR_INVALID_OP_MISSING_ARG);\n return nullptr;\n }\n\n /* We assume that free format is used, and build a full proj_create\n * compatible string */\n char *c = pj_make_args(argc, argv);\n if (nullptr == c) {\n proj_context_errno_set(ctx, PROJ_ERR_INVALID_OP /* ENOMEM */);\n return nullptr;\n }\n\n PJ *P = proj_create(ctx, c);\n\n free((char *)c);\n return P;\n}\n", "authors": {"Thomas Knudsen": 0.3109090909090909, "Even Rouault reformatting bot": 0.49818181818181817, "Even Rouault": 0.09, "Aaron Puchert": 0.1009090909090909}, "leading_author": "Even Rouault reformatting bot", "total_score": 1100.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_errno(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_errno", "assembly": [], "code": "int proj_errno(const PJ *P) {\n /******************************************************************************\n Read an error level from the context of a PJ.\n ******************************************************************************/\n return proj_context_errno(pj_get_ctx((PJ *)P));\n}\n", "authors": {"Thomas Knudsen": 0.9391891891891891, "Even Rouault reformatting bot": 0.060810810810810814}, "leading_author": "Thomas Knudsen", "total_score": 296.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_errno_restore(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_errno_restore", "assembly": [], "code": "int proj_errno_restore(const PJ *P, int err) {\n /******************************************************************************\n Use proj_errno_restore when the current function succeeds, but the\n error flag was set on entry, and stored/reset using proj_errno_reset\n in order to monitor for new errors.\n\n See usage example under proj_errno_reset ()\n ******************************************************************************/\n if (0 == err)\n return 0;\n proj_errno_set(P, err);\n return 0;\n}\n", "authors": {"Even Rouault reformatting bot": 0.1029126213592233, "Thomas Knudsen": 0.8970873786407767}, "leading_author": "Thomas Knudsen", "total_score": 515.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_errno_reset(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_errno_reset", "assembly": [], "code": "int proj_errno_reset(const PJ *P) {\n /******************************************************************************\n Clears errno in the context and thread local levels\n through the low level pj_ctx interface.\n\n Returns the previous value of the errno, for convenient reset/restore\n operations:\n\n int foo (PJ *P) {\n // errno may be set on entry, but we need to reset it to be able to\n // check for errors from \"do_something_with_P(P)\"\n int last_errno = proj_errno_reset (P);\n\n // local failure\n if (0==P)\n return proj_errno_set (P, 42);\n\n // call to function that may fail\n do_something_with_P (P);\n\n // failure in do_something_with_P? - keep latest error status\n if (proj_errno(P))\n return proj_errno (P);\n\n // success - restore previous error status, return 0\n return proj_errno_restore (P, last_errno);\n }\n ******************************************************************************/\n int last_errno;\n last_errno = proj_errno(P);\n\n proj_context_errno_set(pj_get_ctx((PJ *)P), 0);\n errno = 0;\n return last_errno;\n}\n", "authors": {"Even Rouault reformatting bot": 0.007950530035335688, "Thomas Knudsen": 0.9840989399293286, "Kristian Evers": 0.007950530035335688}, "leading_author": "Thomas Knudsen", "total_score": 1132.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_pj_info(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_pj_info", "assembly": [], "code": "PJ_PROJ_INFO proj_pj_info(PJ *P) {\n /******************************************************************************\n Basic info about a particular instance of a projection object.\n\n Returns PJ_PROJ_INFO struct.\n ******************************************************************************/\n PJ_PROJ_INFO pjinfo;\n char *def;\n\n memset(&pjinfo, 0, sizeof(PJ_PROJ_INFO));\n\n pjinfo.accuracy = -1.0;\n\n if (nullptr == P)\n return pjinfo;\n\n /* coordinate operation description */\n if (!P->alternativeCoordinateOperations.empty()) {\n if (P->iCurCoordOp >= 0) {\n P = P->alternativeCoordinateOperations[P->iCurCoordOp].pj;\n } else {\n PJ *candidateOp = nullptr;\n // If there's just a single coordinate operation which is\n // instanciable, use it.\n for (const auto &op : P->alternativeCoordinateOperations) {\n if (op.isInstantiable()) {\n if (candidateOp == nullptr) {\n candidateOp = op.pj;\n } else {\n candidateOp = nullptr;\n break;\n }\n }\n }\n if (candidateOp) {\n P = candidateOp;\n } else {\n pjinfo.id = \"unknown\";\n pjinfo.description = \"unavailable until proj_trans is called\";\n pjinfo.definition = \"unavailable until proj_trans is called\";\n return pjinfo;\n }\n }\n }\n\n /* projection id */\n if (pj_param(P->ctx, P->params, \"tproj\").i)\n pjinfo.id = pj_param(P->ctx, P->params, \"sproj\").s;\n\n pjinfo.description = P->descr;\n if (P->iso_obj) {\n auto identifiedObj =\n dynamic_cast<NS_PROJ::common::IdentifiedObject *>(P->iso_obj.get());\n if (identifiedObj) {\n pjinfo.description = identifiedObj->nameStr().c_str();\n }\n }\n\n // accuracy\n if (P->iso_obj) {\n auto conv = dynamic_cast<const NS_PROJ::operation::Conversion *>(\n P->iso_obj.get());\n if (conv) {\n pjinfo.accuracy = 0.0;\n } else {\n auto op =\n dynamic_cast<const NS_PROJ::operation::CoordinateOperation *>(\n P->iso_obj.get());\n if (op) {\n const auto &accuracies = op->coordinateOperationAccuracies();\n if (!accuracies.empty()) {\n try {\n pjinfo.accuracy = std::stod(accuracies[0]->value());\n } catch (const std::exception &) {\n }\n }\n }\n }\n }\n\n /* projection definition */\n if (P->def_full)\n def = P->def_full;\n else\n def = pj_get_def(P, 0); /* pj_get_def takes a non-const PJ pointer */\n if (nullptr == def)\n pjinfo.definition = empty;\n else\n pjinfo.definition = pj_shrink(def);\n /* Make proj_destroy clean this up eventually */\n P->def_full = def;\n\n pjinfo.has_inverse = pj_has_inverse(P);\n return pjinfo;\n}\n", "authors": {"Kristian Evers": 0.22417285617825794, "Even Rouault reformatting bot": 0.09824442943956786, "Thomas Knudsen": 0.1100607697501688, "Even Rouault": 0.5675219446320054}, "leading_author": "Even Rouault", "total_score": 2962.0, "unique": true}]}, {"file": "/src/analysis/PROJ/src/release.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n/* WARNING: Unknown calling convention -- yet parameter storage is locked */\n\nvoid pj_get_release(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "pj_get_release", "assembly": [], "code": "const char *pj_get_release() { return pj_release; }\n", "authors": {"Even Rouault reformatting bot": 0.7450980392156863, "Kristian Evers": 0.0196078431372549, "Frank Warmerdam": 0.23529411764705882}, "leading_author": "Even Rouault reformatting bot", "total_score": 51.0, "unique": true}]}, {"file": "/src/analysis/PROJ/src/log.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_log_level(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_log_level", "assembly": [], "code": "PJ_LOG_LEVEL proj_log_level(PJ_CONTEXT *ctx, PJ_LOG_LEVEL log_level) {\n /****************************************************************************************\n Set logging level 0-3. Higher number means more debug info. 0 turns it\n off\n ****************************************************************************************/\n PJ_LOG_LEVEL previous;\n if (nullptr == ctx)\n ctx = pj_get_default_ctx();\n if (nullptr == ctx)\n return PJ_LOG_TELL;\n previous = static_cast<PJ_LOG_LEVEL>(abs(ctx->debug_level));\n if (PJ_LOG_TELL == log_level)\n return previous;\n ctx->debug_level = log_level;\n return previous;\n}\n", "authors": {"Even Rouault": 0.9291217257318952, "Even Rouault reformatting bot": 0.07087827426810478}, "leading_author": "Even Rouault", "total_score": 649.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_log_func(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_log_func", "assembly": [], "code": "void proj_log_func(PJ_CONTEXT *ctx, void *app_data, PJ_LOG_FUNCTION logf) {\n /******************************************************************************\n Put a new logging function into P's context. The opaque object app_data\n is passed as first arg at each call to the logger\n ******************************************************************************/\n if (nullptr == ctx)\n ctx = pj_get_default_ctx();\n ctx->logger_app_data = app_data;\n if (nullptr != logf)\n ctx->logger = logf;\n}\n", "authors": {"Even Rouault": 0.9633911368015414, "Even Rouault reformatting bot": 0.036608863198458574}, "leading_author": "Even Rouault", "total_score": 519.0, "unique": true}]}, {"file": "/src/analysis/PROJ/src/strerrno.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_errno_string(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_errno_string", "assembly": [], "code": "const char *proj_errno_string(int err) {\n return proj_context_errno_string(pj_get_default_ctx(), err);\n}\n", "authors": {"Even Rouault reformatting bot": 0.01904761904761905, "Even Rouault": 0.9809523809523809}, "leading_author": "Even Rouault", "total_score": 105.0, "unique": true}]}, {"file": "/src/analysis/PROJ/src/malloc.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_destroy(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_destroy", "assembly": [], "code": "PJ *proj_destroy(PJ *P) {\n if (nullptr == P || !P->destructor)\n return nullptr;\n /* free projection parameters - all the hard work is done by */\n /* pj_default_destructor, which is supposed */\n /* to be called as the last step of the local destructor */\n /* pointed to by P->destructor. In most cases, */\n /* pj_default_destructor actually *is* what is pointed to */\n P->destructor(P, proj_errno(P));\n return nullptr;\n}\n", "authors": {"Kristian Evers": 0.09978308026030369, "Thomas Knudsen": 0.737527114967462, "Even Rouault reformatting bot": 0.16268980477223427}, "leading_author": "Thomas Knudsen", "total_score": 461.0, "unique": true}]}, {"file": "/src/analysis/PROJ/src/filemanager.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n/* WARNING: Unknown calling convention -- yet parameter storage is locked */\n\nvoid pj_stderr_proj_lib_deprecation_warning(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "pj_stderr_proj_lib_deprecation_warning", "assembly": [], "code": "void pj_stderr_proj_lib_deprecation_warning() {\n if (getenv(\"PROJ_LIB\") != nullptr && getenv(\"PROJ_DATA\") == nullptr) {\n fprintf(stderr, \"DeprecationWarning: PROJ_LIB environment variable is \"\n \"deprecated, and will be removed in a future release. \"\n \"You are encouraged to set PROJ_DATA instead.\\n\");\n }\n}\n", "authors": {"Even Rouault": 1.0}, "leading_author": "Even Rouault", "total_score": 343.0, "unique": true}]}, {"file": "/src/analysis/PROJ/src/apps/cct.cpp", "functions": [{"p_code_refined": ["(unique, 0x10000076, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8)", "(unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8)", "(unique, 0x4f00, 8) CAST (unique, 0x10000076, 8)", "(register, 0x0, 8) CALL (ram, 0x1066d4, 8) , (register, 0x38, 8) , (register, 0x30, 4)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x2f, 4)", "(ram, 0x108fb0, 8) INDIRECT (ram, 0x108fb0, 8) , (const, 0x2f, 4)", "(stack, 0xffffffffffffffd8, 8) INDIRECT (stack, 0xffffffffffffffd8, 8) , (const, 0x2f, 4)", "(stack, 0xfffffffffffffff0, 8) INDIRECT (unique, 0xc300, 8) , (const, 0x2f, 4)", "(unique, 0x3100, 8) PTRSUB (register, 0x20, 8) , (const, 0xffffffffffffffd8, 8)", "(register, 0x1200, 8) CALL (ram, 0x106ac3, 8) , (register, 0x0, 8) , (unique, 0x3100, 8)", "(register, 0x110, 8) INDIRECT (register, 0x110, 8) , (const, 0x3c, 4)", "(ram, 0x108fb0, 8) INDIRECT (ram, 0x108fb0, 8) , (const, 0x3c, 4)", "(stack, 0xffffffffffffffd8, 8) INDIRECT (stack, 0xffffffffffffffd8, 8) , (const, 0x3c, 4)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (register, 0x0, 8) , (const, 0x3c, 4)", "(stack, 0xfffffffffffffff0, 8) INDIRECT (stack, 0xfffffffffffffff0, 8) , (const, 0x3c, 4)", "(register, 0x206, 1) INT_EQUAL (stack, 0xffffffffffffffe0, 8) , (stack, 0xffffffffffffffd8, 8)", " --- CBRANCH (ram, 0x1067ea, 1) , (register, 0x206, 1)", "(unique, 0x1000006e, 8) COPY (register, 0x1200, 8)", " --- BRANCH (ram, 0x1067ef, 1)", "(unique, 0x10000066, 8) COPY (ram, 0x108fb0, 8)", "(register, 0x1200, 8) MULTIEQUAL (unique, 0x10000066, 8) , (unique, 0x1000006e, 8)", "(unique, 0x1000007e, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8)", "(unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8)", "(register, 0x206, 1) INT_EQUAL (stack, 0xfffffffffffffff0, 8) , (unique, 0xc300, 8)", "(unique, 0x4f00, 8) CAST (unique, 0x1000007e, 8)", " --- CBRANCH (ram, 0x106803, 1) , (register, 0x206, 1)", " --- CALL (ram, 0x103640, 8)", " --- RETURN (const, 0x1, 4)", "(ram, 0x108fb0, 8) INDIRECT (ram, 0x108fb0, 8) , (const, 0x66, 4)", "(ram, 0x108fb0, 8) COPY (ram, 0x108fb0, 8)", "(stack, 0xffffffffffffffe0, 8) INDIRECT (stack, 0xffffffffffffffe0, 8) , (const, 0x66, 4)", "(stack, 0xffffffffffffffe8, 8) INDIRECT (register, 0x1200, 8) , (const, 0x66, 4)", "(stack, 0xfffffffffffffff0, 8) INDIRECT (stack, 0xfffffffffffffff0, 8) , (const, 0x66, 4)", " --- RETURN (const, 0x0, 8) , (register, 0x1200, 8)", "(ram, 0x108fb0, 8) COPY (ram, 0x108fb0, 8)"], "raw": ["f30f1efa", "55", "4889e5", "4883ec30", "48897dd8", "8975d4", "64488b042528000000", "488945f8", "31c0", "8b55d4", "488b45d8", "89d6", "4889c7", "e81effffff", "488945e8", "488d55e0", "488b45e8", "4889d6", "4889c7", "e8f6020000", "66480f7ec0", "488945f0", "488b45e0", "483945e8", "750a", "f20f1005c8270000", "eb05", "f20f1045f0", "488b45f8", "644833042528000000", "7405", "e83dceffff", "c9", "c3"], "c_code": "\ndouble cold(char *args,int col)\n\n{\n long in_FS_OFFSET;\n double dVar1;\n int col_local;\n char *args_local;\n char *endp;\n char *target;\n double d;\n long local_10;\n \n local_10 = *(long *)(in_FS_OFFSET + 0x28);\n target = column(args,col);\n d = proj_strtod(target,&endp);\n dVar1 = d;\n if (target == endp) {\n dVar1 = DAT_00108fb0;\n }\n if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {\n return dVar1;\n }\n /* WARNING: Subroutine does not return */\n __stack_chk_fail();\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_LESS (register, 0x20, 8) , (const, 0x30, 8), (register, 0x20b, 1) INT_SBORROW (register, 0x20, 8) , (const, 0x30, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x30, 8), (register, 0x207, 1) INT_SLESS (register, 0x20, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x20, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x20, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd8, 8), (unique, 0x5500, 8) COPY (register, 0x38, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd4, 8), (unique, 0x5480, 4) COPY (register, 0x30, 4), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5480, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x4f00, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (register, 0x0, 4) INT_XOR (register, 0x0, 4) , (register, 0x0, 4), (register, 0x0, 8) INT_ZEXT (register, 0x0, 4), (register, 0x207, 1) INT_SLESS (register, 0x0, 4) , (const, 0x0, 4), (register, 0x206, 1) INT_EQUAL (register, 0x0, 4) , (const, 0x0, 4), (unique, 0x13480, 4) INT_AND (register, 0x0, 4) , (const, 0xff, 4), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 4), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd4, 8), (unique, 0xc200, 4) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x10, 4) COPY (unique, 0xc200, 4), (register, 0x10, 8) INT_ZEXT (register, 0x10, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffd8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 4) COPY (register, 0x10, 4), (register, 0x30, 8) INT_ZEXT (register, 0x30, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x1067b6, 8), --- CALL (ram, 0x1066d4, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe0, 8), (register, 0x10, 8) COPY (unique, 0x3100, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (register, 0x10, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x1067cd, 8), --- CALL (ram, 0x106ac3, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x0, 8) SUBPIECE (register, 0x1200, 16) , (const, 0x0, 4)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0x5500, 8) COPY (register, 0x0, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe0, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xffffffffffffffe8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (unique, 0x26180, 8) COPY (unique, 0xc300, 8), (register, 0x200, 1) INT_LESS (unique, 0x26180, 8) , (register, 0x0, 8), (register, 0x20b, 1) INT_SBORROW (unique, 0x26180, 8) , (register, 0x0, 8), (unique, 0x26280, 8) INT_SUB (unique, 0x26180, 8) , (register, 0x0, 8), (register, 0x207, 1) INT_SLESS (unique, 0x26280, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (unique, 0x26280, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (unique, 0x26280, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xcc00, 1) BOOL_NEGATE (register, 0x206, 1), --- CBRANCH (ram, 0x1067ea, 8) , (unique, 0xcc00, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x1200, 8) COPY (ram, 0x108fb0, 8), (register, 0x1208, 8) COPY (const, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- BRANCH (ram, 0x1067ef, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff0, 8), (unique, 0x5500, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x1200, 8) COPY (unique, 0x5500, 8), (register, 0x1208, 8) COPY (const, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x4f00, 8) INT_ADD (register, 0x110, 8) , (const, 0x28, 8), (register, 0x200, 1) COPY (const, 0x0, 1), (register, 0x20b, 1) COPY (const, 0x0, 1), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x4f00, 8), (register, 0x0, 8) INT_XOR (register, 0x0, 8) , (unique, 0xc300, 8), (register, 0x207, 1) INT_SLESS (register, 0x0, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x0, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x0, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [ --- CBRANCH (ram, 0x106803, 8) , (register, 0x206, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x106803, 8), --- CALL (ram, 0x103640, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) COPY (register, 0x28, 8), (register, 0x28, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "cold", "assembly": ["ENDBR64", "PUSH RBP", "MOV RBP,RSP", "SUB RSP,0x30", "MOV qword ptr [RBP + -0x28],RDI", "MOV dword ptr [RBP + -0x2c],ESI", "MOV RAX,qword ptr FS:[0x28]", "MOV qword ptr [RBP + -0x8],RAX", "XOR EAX,EAX", "MOV EDX,dword ptr [RBP + -0x2c]", "MOV RAX,qword ptr [RBP + -0x28]", "MOV ESI,EDX", "MOV RDI,RAX", "CALL 0x001066d4", "MOV qword ptr [RBP + -0x18],RAX", "LEA RDX,[RBP + -0x20]", "MOV RAX,qword ptr [RBP + -0x18]", "MOV RSI,RDX", "MOV RDI,RAX", "CALL 0x00106ac3", "MOVQ RAX,XMM0", "MOV qword ptr [RBP + -0x10],RAX", "MOV RAX,qword ptr [RBP + -0x20]", "CMP qword ptr [RBP + -0x18],RAX", "JNZ 0x001067ea", "MOVSD XMM0,qword ptr [0x00108fb0]", "JMP 0x001067ef", "MOVSD XMM0,qword ptr [RBP + -0x10]", "MOV RAX,qword ptr [RBP + -0x8]", "XOR RAX,qword ptr FS:[0x28]", "JZ 0x00106803", "CALL 0x00103640", "LEAVE", "RET"], "code": "static double cold(const char *args, int col) {\n char *endp;\n double d;\n const char *target = column(args, col);\n d = proj_strtod(target, &endp);\n if (endp == target)\n return HUGE_VAL;\n return d;\n}\n", "authors": {"Even Rouault": 0.4158878504672897, "Thomas Knudsen": 0.5700934579439252, "Even Rouault reformatting bot": 0.014018691588785047}, "leading_author": "Thomas Knudsen", "total_score": 214.0, "unique": true}]}, {"file": "/src/analysis/PROJ/src/apps/proj_strtod.cpp", "functions": [{"p_code_refined": ["(register, 0x1200, 8) CALL (ram, 0x106ac3, 8) , (register, 0x38, 8) , (const, 0x0, 8)", " --- RETURN (const, 0x0, 8) , (register, 0x1200, 8)"], "raw": ["f30f1efa", "55", "4889e5", "4883ec10", "48897df8", "488b45f8", "be00000000", "4889c7", "e8aaf8ffff", "c9", "c3"], "c_code": "\ndouble proj_atof(char *str)\n\n{\n double dVar1;\n char *str_local;\n \n dVar1 = proj_strtod(str,(char **)0x0);\n return dVar1;\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x200, 1) INT_LESS (register, 0x20, 8) , (const, 0x10, 8), (register, 0x20b, 1) INT_SBORROW (register, 0x20, 8) , (const, 0x10, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x10, 8), (register, 0x207, 1) INT_SLESS (register, 0x20, 8) , (const, 0x0, 8), (register, 0x206, 1) INT_EQUAL (register, 0x20, 8) , (const, 0x0, 8), (unique, 0x13480, 8) INT_AND (register, 0x20, 8) , (const, 0xff, 8), (unique, 0x13500, 1) POPCOUNT (unique, 0x13480, 8), (unique, 0x13580, 1) INT_AND (unique, 0x13500, 1) , (const, 0x1, 1), (register, 0x202, 1) INT_EQUAL (unique, 0x13580, 1) , (const, 0x0, 1)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0x5500, 8) COPY (register, 0x38, 8), --- STORE (const, 0x1b1, 4) , (unique, 0x3100, 8) , (unique, 0x5500, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3100, 8) INT_ADD (register, 0x28, 8) , (const, 0xfffffffffffffff8, 8), (unique, 0xc300, 8) LOAD (const, 0x1b1, 4) , (unique, 0x3100, 8), (register, 0x0, 8) COPY (unique, 0xc300, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x30, 8) COPY (const, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x38, 8) COPY (register, 0x0, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x107219, 8), --- CALL (ram, 0x106ac3, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) COPY (register, 0x28, 8), (register, 0x28, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "proj_atof", "assembly": ["ENDBR64", "PUSH RBP", "MOV RBP,RSP", "SUB RSP,0x10", "MOV qword ptr [RBP + -0x8],RDI", "MOV RAX,qword ptr [RBP + -0x8]", "MOV ESI,0x0", "MOV RDI,RAX", "CALL 0x00106ac3", "LEAVE", "RET"], "code": "double proj_atof(const char *str) { return proj_strtod(str, nullptr); }\n", "authors": {"Even Rouault reformatting bot": 0.7605633802816901, "Thomas Knudsen": 0.23943661971830985}, "leading_author": "Even Rouault reformatting bot", "total_score": 71.0, "unique": true}]}, {"file": "/src/analysis/PROJ/src/iso19111/c_api.cpp", "functions": [{"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_create(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_create", "assembly": [], "code": "PJ *proj_create(PJ_CONTEXT *ctx, const char *text) {\n SANITIZE_CTX(ctx);\n if (!text) {\n proj_context_errno_set(ctx, PROJ_ERR_OTHER_API_MISUSE);\n proj_log_error(ctx, __FUNCTION__, \"missing required input\");\n return nullptr;\n }\n\n // Only connect to proj.db if needed\n if (strstr(text, \"proj=\") == nullptr || strstr(text, \"init=\") != nullptr) {\n getDBcontextNoException(ctx, __FUNCTION__);\n }\n try {\n auto obj =\n nn_dynamic_pointer_cast<BaseObject>(createFromUserInput(text, ctx));\n if (obj) {\n return pj_obj_create(ctx, NN_NO_CHECK(obj));\n }\n } catch (const io::ParsingException &e) {\n if (proj_context_errno(ctx) == 0) {\n proj_context_errno_set(ctx, PROJ_ERR_INVALID_OP_WRONG_SYNTAX);\n }\n proj_log_error(ctx, __FUNCTION__, e.what());\n } catch (const NoSuchAuthorityCodeException &e) {\n proj_log_error(ctx, __FUNCTION__,\n std::string(e.what())\n .append(\": \")\n .append(e.getAuthority())\n .append(\":\")\n .append(e.getAuthorityCode())\n .c_str());\n } catch (const std::exception &e) {\n proj_log_error(ctx, __FUNCTION__, e.what());\n }\n return nullptr;\n}\n", "authors": {"Even Rouault": 0.7460197119029568, "Alan D. Snow": 0.08491281273692192, "Brendan Jurd": 0.16906747536012132}, "leading_author": "Even Rouault", "total_score": 1319.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_create_from_database(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_create_from_database", "assembly": [], "code": "PJ *proj_create_from_database(PJ_CONTEXT *ctx, const char *auth_name,\n const char *code, PJ_CATEGORY category,\n int usePROJAlternativeGridNames,\n const char *const *options) {\n SANITIZE_CTX(ctx);\n if (!auth_name || !code) {\n proj_context_errno_set(ctx, PROJ_ERR_OTHER_API_MISUSE);\n proj_log_error(ctx, __FUNCTION__, \"missing required input\");\n return nullptr;\n }\n (void)options;\n try {\n const std::string codeStr(code);\n auto factory = AuthorityFactory::create(getDBcontext(ctx), auth_name);\n IdentifiedObjectPtr obj;\n switch (category) {\n case PJ_CATEGORY_ELLIPSOID:\n obj = factory->createEllipsoid(codeStr).as_nullable();\n break;\n case PJ_CATEGORY_PRIME_MERIDIAN:\n obj = factory->createPrimeMeridian(codeStr).as_nullable();\n break;\n case PJ_CATEGORY_DATUM:\n obj = factory->createDatum(codeStr).as_nullable();\n break;\n case PJ_CATEGORY_CRS:\n obj =\n factory->createCoordinateReferenceSystem(codeStr).as_nullable();\n break;\n case PJ_CATEGORY_COORDINATE_OPERATION:\n obj = factory\n ->createCoordinateOperation(\n codeStr, usePROJAlternativeGridNames != 0)\n .as_nullable();\n break;\n case PJ_CATEGORY_DATUM_ENSEMBLE:\n obj = factory->createDatumEnsemble(codeStr).as_nullable();\n break;\n }\n return pj_obj_create(ctx, NN_NO_CHECK(obj));\n } catch (const NoSuchAuthorityCodeException &e) {\n proj_log_error(ctx, __FUNCTION__,\n std::string(e.what())\n .append(\": \")\n .append(e.getAuthority())\n .append(\":\")\n .append(e.getAuthorityCode())\n .c_str());\n } catch (const std::exception &e) {\n proj_log_error(ctx, __FUNCTION__, e.what());\n }\n return nullptr;\n}\n", "authors": {"Even Rouault": 0.9315263908701854, "Alan D. Snow": 0.06847360912981455}, "leading_author": "Even Rouault", "total_score": 2103.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_get_type(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_get_type", "assembly": [], "code": "PJ_TYPE proj_get_type(const PJ *obj) {\n if (!obj || !obj->iso_obj) {\n return PJ_TYPE_UNKNOWN;\n }\n if (obj->type != PJ_TYPE_UNKNOWN)\n return obj->type;\n\n const auto getType = [&obj]() {\n auto ptr = obj->iso_obj.get();\n if (dynamic_cast<Ellipsoid *>(ptr)) {\n return PJ_TYPE_ELLIPSOID;\n }\n\n if (dynamic_cast<PrimeMeridian *>(ptr)) {\n return PJ_TYPE_PRIME_MERIDIAN;\n }\n\n if (dynamic_cast<DynamicGeodeticReferenceFrame *>(ptr)) {\n return PJ_TYPE_DYNAMIC_GEODETIC_REFERENCE_FRAME;\n }\n if (dynamic_cast<GeodeticReferenceFrame *>(ptr)) {\n return PJ_TYPE_GEODETIC_REFERENCE_FRAME;\n }\n if (dynamic_cast<DynamicVerticalReferenceFrame *>(ptr)) {\n return PJ_TYPE_DYNAMIC_VERTICAL_REFERENCE_FRAME;\n }\n if (dynamic_cast<VerticalReferenceFrame *>(ptr)) {\n return PJ_TYPE_VERTICAL_REFERENCE_FRAME;\n }\n if (dynamic_cast<DatumEnsemble *>(ptr)) {\n return PJ_TYPE_DATUM_ENSEMBLE;\n }\n if (dynamic_cast<TemporalDatum *>(ptr)) {\n return PJ_TYPE_TEMPORAL_DATUM;\n }\n if (dynamic_cast<EngineeringDatum *>(ptr)) {\n return PJ_TYPE_ENGINEERING_DATUM;\n }\n if (dynamic_cast<ParametricDatum *>(ptr)) {\n return PJ_TYPE_PARAMETRIC_DATUM;\n }\n\n if (auto crs = dynamic_cast<GeographicCRS *>(ptr)) {\n if (crs->coordinateSystem()->axisList().size() == 2) {\n return PJ_TYPE_GEOGRAPHIC_2D_CRS;\n } else {\n return PJ_TYPE_GEOGRAPHIC_3D_CRS;\n }\n }\n\n if (auto crs = dynamic_cast<GeodeticCRS *>(ptr)) {\n if (crs->isGeocentric()) {\n return PJ_TYPE_GEOCENTRIC_CRS;\n } else {\n return PJ_TYPE_GEODETIC_CRS;\n }\n }\n\n if (dynamic_cast<VerticalCRS *>(ptr)) {\n return PJ_TYPE_VERTICAL_CRS;\n }\n if (dynamic_cast<ProjectedCRS *>(ptr)) {\n return PJ_TYPE_PROJECTED_CRS;\n }\n if (dynamic_cast<DerivedProjectedCRS *>(ptr)) {\n return PJ_TYPE_DERIVED_PROJECTED_CRS;\n }\n if (dynamic_cast<CompoundCRS *>(ptr)) {\n return PJ_TYPE_COMPOUND_CRS;\n }\n if (dynamic_cast<TemporalCRS *>(ptr)) {\n return PJ_TYPE_TEMPORAL_CRS;\n }\n if (dynamic_cast<EngineeringCRS *>(ptr)) {\n return PJ_TYPE_ENGINEERING_CRS;\n }\n if (dynamic_cast<BoundCRS *>(ptr)) {\n return PJ_TYPE_BOUND_CRS;\n }\n if (dynamic_cast<CRS *>(ptr)) {\n return PJ_TYPE_OTHER_CRS;\n }\n\n if (dynamic_cast<Conversion *>(ptr)) {\n return PJ_TYPE_CONVERSION;\n }\n if (dynamic_cast<Transformation *>(ptr)) {\n return PJ_TYPE_TRANSFORMATION;\n }\n if (dynamic_cast<ConcatenatedOperation *>(ptr)) {\n return PJ_TYPE_CONCATENATED_OPERATION;\n }\n if (dynamic_cast<CoordinateOperation *>(ptr)) {\n return PJ_TYPE_OTHER_COORDINATE_OPERATION;\n }\n\n if (dynamic_cast<CoordinateMetadata *>(ptr)) {\n return PJ_TYPE_COORDINATE_METADATA;\n }\n\n return PJ_TYPE_UNKNOWN;\n };\n\n obj->type = getType();\n return obj->type;\n}\n", "authors": {"Even Rouault": 0.8577658503857766, "Alan D. Snow": 0.005031868500503187, "snowman2": 0.09191546460919155, "Javier Jimenez Shaw": 0.04528681650452868}, "leading_author": "Even Rouault", "total_score": 2981.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_is_crs(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_is_crs", "assembly": [], "code": "int proj_is_crs(const PJ *obj) {\n if (!obj) {\n return false;\n }\n return dynamic_cast<CRS *>(obj->iso_obj.get()) != nullptr;\n}\n", "authors": {"Even Rouault": 0.6985294117647058, "Alan D. Snow": 0.3014705882352941}, "leading_author": "Even Rouault", "total_score": 136.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_get_authorities_from_database(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_get_authorities_from_database", "assembly": [], "code": "PROJ_STRING_LIST proj_get_authorities_from_database(PJ_CONTEXT *ctx) {\n SANITIZE_CTX(ctx);\n try {\n auto ret = to_string_list(getDBcontext(ctx)->getAuthorities());\n return ret;\n } catch (const std::exception &e) {\n proj_log_error(ctx, __FUNCTION__, e.what());\n }\n return nullptr;\n}\n", "authors": {"Even Rouault": 1.0}, "leading_author": "Even Rouault", "total_score": 307.0, "unique": true}, {"p_code_refined": [" --- RETURN (const, 0x1, 4)"], "raw": [], "c_code": "\n/* WARNING: Control flow encountered bad instruction data */\n\nvoid proj_string_list_destroy(void)\n\n{\n /* WARNING: Bad instruction - Truncating control flow here */\n halt_baddata();\n}\n\n", "p_code": [], "name": "proj_string_list_destroy", "assembly": [], "code": "void proj_string_list_destroy(PROJ_STRING_LIST list) {\n if (list) {\n for (size_t i = 0; list[i] != nullptr; i++) {\n delete[] list[i];\n }\n delete[] list;\n }\n}\n", "authors": {"Even Rouault": 1.0}, "leading_author": "Even Rouault", "total_score": 188.0, "unique": true}]}]}
|
datasets/conan/PlatformFolders.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/QCBOR.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/RVO2.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/SPIRV-Cross.json
ADDED
|
The diff for this file is too large to render.
See raw diff
|
|
|
datasets/conan/SQLite3MultipleCiphers.json
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:b255e3e6d4a20bd7e138e47da321810c41efa58f7ce3518b6cce352fc6708f9a
|
| 3 |
+
size 173883668
|
datasets/conan/SQLiteCpp.json
ADDED
|
@@ -0,0 +1 @@
|
|
|
|
|
|
|
| 1 |
+
{"commit_hash": "08aa70a45ea52abcd8ee6b5d1ab1542140b3c7f5", "data": [{"file": "/src/analysis/SQLiteCpp/src/Database.cpp", "functions": [{"p_code_refined": ["(register, 0x0, 8) CALL (ram, 0x1fd5aa, 8)", " --- RETURN (const, 0x0, 8) , (register, 0x0, 8)"], "raw": ["f30f1efa", "55", "4889e5", "e83d080e00", "5d", "c3"], "c_code": "\n/* WARNING: Unknown calling convention */\n\nchar * SQLite::getLibVersion(void)\n\n{\n char *pcVar1;\n \n pcVar1 = sqlite3_libversion();\n return pcVar1;\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x11cd6d, 8), --- CALL (ram, 0x1fd5aa, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3c380, 8) COPY (const, 0x0, 8), (unique, 0x3c380, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), (register, 0x28, 8) COPY (unique, 0x3c380, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "getLibVersion", "assembly": ["ENDBR64", "PUSH RBP", "MOV RBP,RSP", "CALL 0x001fd5aa", "POP RBP", "RET"], "code": "const char* getLibVersion() noexcept\n{\n return sqlite3_libversion();\n}\n", "authors": {"S\u00e9bastien Rombauts": 1.0}, "leading_author": "S\u00e9bastien Rombauts", "total_score": 70.0, "unique": true}, {"p_code_refined": ["(register, 0x0, 4) CALL (ram, 0x1fd5bb, 8)", " --- RETURN (const, 0x0, 8) , (register, 0x0, 4)"], "raw": ["f30f1efa", "55", "4889e5", "e83f080e00", "5d", "c3"], "c_code": "\n/* WARNING: Unknown calling convention */\n\nint SQLite::getLibVersionNumber(void)\n\n{\n int iVar1;\n \n iVar1 = sqlite3_libversion_number();\n return iVar1;\n}\n\n", "p_code": ["array(ghidra.program.model.pcode.PcodeOp)", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0xf000, 8) COPY (register, 0x28, 8), (register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (unique, 0xf000, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x28, 8) COPY (register, 0x20, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x20, 8) INT_SUB (register, 0x20, 8) , (const, 0x8, 8), --- STORE (const, 0x1b1, 8) , (register, 0x20, 8) , (const, 0x11cd7c, 8), --- CALL (ram, 0x1fd5bb, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(unique, 0x3c380, 8) COPY (const, 0x0, 8), (unique, 0x3c380, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), (register, 0x28, 8) COPY (unique, 0x3c380, 8)])", "array(ghidra.program.model.pcode.PcodeOp, [(register, 0x288, 8) LOAD (const, 0x1b1, 8) , (register, 0x20, 8), (register, 0x20, 8) INT_ADD (register, 0x20, 8) , (const, 0x8, 8), --- RETURN (register, 0x288, 8)])"], "name": "getLibVersionNumber", "assembly": ["ENDBR64", "PUSH RBP", "MOV RBP,RSP", "CALL 0x001fd5bb", "POP RBP", "RET"], "code": "int getLibVersionNumber() noexcept\n{\n return sqlite3_libversion_number();\n}\n", "authors": {"S\u00e9bastien Rombauts": 1.0}, "leading_author": "S\u00e9bastien Rombauts", "total_score": 75.0, "unique": true}]}]}
|
datasets/conan/SVT-JPEG-XS.json
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
version https://git-lfs.github.com/spec/v1
|
| 2 |
+
oid sha256:d10feff5cf10340213141702dad8e52d8f2f9df046afa586fdc6f3dda990fc0d
|
| 3 |
+
size 33441176
|