Loading [MathJax]/extensions/tex2jax.js
libTriton version 1.0 build 1599
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
pyTritonContext.cpp
Go to the documentation of this file.
1
2/*
3** Copyright (C) - Triton
4**
5** This program is under the terms of the Apache License 2.0.
6*/
7
8#include <triton/pythonObjects.hpp>
9#include <triton/pythonUtils.hpp>
10#include <triton/pythonXFunctions.hpp>
11#include <triton/arm32Cpu.hpp>
12#include <triton/context.hpp>
13#include <triton/exceptions.hpp>
14#include <triton/register.hpp>
15
16
17
464namespace triton {
465 namespace bindings {
466 namespace python {
467
468 static void TritonContext_dealloc(PyObject* self) {
469 if (((TritonContext_Object*)self)->ref == false)
470 delete PyTritonContext_AsTritonContext(self);
471 Py_XDECREF(((TritonContext_Object*)self)->regAttr);
472 Py_TYPE(self)->tp_free((PyObject*)self);
473 }
474
475
476 static void TritonContext_fillRegistersAttribute(PyObject* self) {
477 /* Fill self->regAttr */
478 auto& regs = PyTritonContext_AsTritonContext(self)->getAllRegisters();
479
480 PyObject* registersDict = xPyDict_New();
481 for (auto& reg : regs)
482 xPyDict_SetItem(registersDict, xPyString_FromString(reg.second.getName().c_str()), PyRegister(reg.second));
483
484 Py_XDECREF(((TritonContext_Object*)(self))->regAttr);
485 ((TritonContext_Object*)(self))->regAttr = xPyClass_New(nullptr, registersDict, xPyString_FromString("registers"));
486 }
487
488
489 static PyObject* TritonContext_addCallback(PyObject* self, PyObject* args) {
490 PyObject* function = nullptr;
491 PyObject* mode = nullptr;
492 PyObject* cb = nullptr;
493 PyObject* cb_self = nullptr;
494
495 /* Extract arguments */
496 if (PyArg_ParseTuple(args, "|OO", &mode, &function) == false) {
497 return PyErr_Format(PyExc_TypeError, "TritonContext::addCallback(): Invalid number of arguments");
498 }
499
500 if (mode == nullptr || (!PyLong_Check(mode) && !PyInt_Check(mode)))
501 return PyErr_Format(PyExc_TypeError, "TritonContext::addCallback(): Expects a CALLBACK as first argument.");
502
503 if (function == nullptr || !PyCallable_Check(function))
504 return PyErr_Format(PyExc_TypeError, "TritonContext::addCallback(): Expects a function as second argument.");
505
506 if (PyMethod_Check(function)) {
507 cb_self = PyMethod_GET_SELF(function);
508 cb = PyMethod_GET_FUNCTION(function);
509 Py_INCREF(cb_self);
510 }
511 else {
512 cb = function;
513 }
514 Py_INCREF(cb);
515
516 try {
517 switch (static_cast<triton::callbacks::callback_e>(PyLong_AsUint32(mode))) {
518
519 case callbacks::GET_CONCRETE_MEMORY_VALUE:
520 PyTritonContext_AsTritonContext(self)->addCallback(callbacks::GET_CONCRETE_MEMORY_VALUE, callbacks::getConcreteMemoryValueCallback([cb_self, cb](triton::Context& ctx, const triton::arch::MemoryAccess& mem) {
521 /********* Lambda *********/
522 PyObject* args = nullptr;
523
524 /* Create function args */
525 if (cb_self) {
526 args = triton::bindings::python::xPyTuple_New(3);
527 PyTuple_SetItem(args, 0, cb_self);
528 PyTuple_SetItem(args, 1, triton::bindings::python::PyTritonContextRef(ctx));
529 PyTuple_SetItem(args, 2, triton::bindings::python::PyMemoryAccess(mem));
530 Py_INCREF(cb_self);
531 }
532 else {
533 args = triton::bindings::python::xPyTuple_New(2);
534 PyTuple_SetItem(args, 0, triton::bindings::python::PyTritonContextRef(ctx));
535 PyTuple_SetItem(args, 1, triton::bindings::python::PyMemoryAccess(mem));
536 }
537
538 /* Call the callback */
539 PyObject* ret = PyObject_CallObject(cb, args);
540
541 /* Release args */
542 Py_DECREF(args);
543
544 /* Check the call */
545 if (ret == nullptr) {
546 throw triton::exceptions::PyCallbacks();
547 }
548 /********* End of lambda *********/
549 }, cb));
550 break;
551
552 case callbacks::GET_CONCRETE_REGISTER_VALUE:
553 PyTritonContext_AsTritonContext(self)->addCallback(callbacks::GET_CONCRETE_REGISTER_VALUE, callbacks::getConcreteRegisterValueCallback([cb_self, cb](triton::Context& ctx, const triton::arch::Register& reg){
554 /********* Lambda *********/
555 PyObject* args = nullptr;
556
557 /* Create function args */
558 if (cb_self) {
559 args = triton::bindings::python::xPyTuple_New(3);
560 PyTuple_SetItem(args, 0, cb_self);
561 PyTuple_SetItem(args, 1, triton::bindings::python::PyTritonContextRef(ctx));
562 PyTuple_SetItem(args, 2, triton::bindings::python::PyRegister(reg));
563 Py_INCREF(cb_self);
564 }
565 else {
566 args = triton::bindings::python::xPyTuple_New(2);
567 PyTuple_SetItem(args, 0, triton::bindings::python::PyTritonContextRef(ctx));
568 PyTuple_SetItem(args, 1, triton::bindings::python::PyRegister(reg));
569 }
570
571 /* Call the callback */
572 PyObject* ret = PyObject_CallObject(cb, args);
573
574 /* Release args */
575 Py_DECREF(args);
576
577 /* Check the call */
578 if (ret == nullptr) {
579 throw triton::exceptions::PyCallbacks();
580 }
581 /********* End of lambda *********/
582 }, cb));
583 break;
584
585 case callbacks::SET_CONCRETE_MEMORY_VALUE:
586 PyTritonContext_AsTritonContext(self)->addCallback(callbacks::SET_CONCRETE_MEMORY_VALUE, callbacks::setConcreteMemoryValueCallback([cb_self, cb](triton::Context& ctx, const triton::arch::MemoryAccess& mem, const triton::uint512& value) {
587 /********* Lambda *********/
588 PyObject* args = nullptr;
589
590 /* Create function args */
591 if (cb_self) {
592 args = triton::bindings::python::xPyTuple_New(4);
593 PyTuple_SetItem(args, 0, cb_self);
594 PyTuple_SetItem(args, 1, triton::bindings::python::PyTritonContextRef(ctx));
595 PyTuple_SetItem(args, 2, triton::bindings::python::PyMemoryAccess(mem));
596 PyTuple_SetItem(args, 3, triton::bindings::python::PyLong_FromUint512(value));
597 Py_INCREF(cb_self);
598 }
599 else {
600 args = triton::bindings::python::xPyTuple_New(3);
601 PyTuple_SetItem(args, 0, triton::bindings::python::PyTritonContextRef(ctx));
602 PyTuple_SetItem(args, 1, triton::bindings::python::PyMemoryAccess(mem));
603 PyTuple_SetItem(args, 2, triton::bindings::python::PyLong_FromUint512(value));
604 }
605
606 /* Call the callback */
607 PyObject* ret = PyObject_CallObject(cb, args);
608
609 /* Release args */
610 Py_DECREF(args);
611
612 /* Check the call */
613 if (ret == nullptr) {
614 throw triton::exceptions::PyCallbacks();
615 }
616 /********* End of lambda *********/
617 }, cb));
618 break;
619
620 case callbacks::SET_CONCRETE_REGISTER_VALUE:
621 PyTritonContext_AsTritonContext(self)->addCallback(callbacks::SET_CONCRETE_REGISTER_VALUE, callbacks::setConcreteRegisterValueCallback([cb_self, cb](triton::Context& ctx, const triton::arch::Register& reg, const triton::uint512& value){
622 /********* Lambda *********/
623 PyObject* args = nullptr;
624
625 /* Create function args */
626 if (cb_self) {
627 args = triton::bindings::python::xPyTuple_New(4);
628 PyTuple_SetItem(args, 0, cb_self);
629 PyTuple_SetItem(args, 1, triton::bindings::python::PyTritonContextRef(ctx));
630 PyTuple_SetItem(args, 2, triton::bindings::python::PyRegister(reg));
631 PyTuple_SetItem(args, 3, triton::bindings::python::PyLong_FromUint512(value));
632 Py_INCREF(cb_self);
633 }
634 else {
635 args = triton::bindings::python::xPyTuple_New(3);
636 PyTuple_SetItem(args, 0, triton::bindings::python::PyTritonContextRef(ctx));
637 PyTuple_SetItem(args, 1, triton::bindings::python::PyRegister(reg));
638 PyTuple_SetItem(args, 2, triton::bindings::python::PyLong_FromUint512(value));
639 }
640
641 /* Call the callback */
642 PyObject* ret = PyObject_CallObject(cb, args);
643
644 /* Release args */
645 Py_DECREF(args);
646
647 /* Check the call */
648 if (ret == nullptr) {
649 throw triton::exceptions::PyCallbacks();
650 }
651 /********* End of lambda *********/
652 }, cb));
653 break;
654
655 case callbacks::SYMBOLIC_SIMPLIFICATION:
656 PyTritonContext_AsTritonContext(self)->addCallback(callbacks::SYMBOLIC_SIMPLIFICATION, callbacks::symbolicSimplificationCallback([cb_self, cb](triton::Context& ctx, triton::ast::SharedAbstractNode node) {
657 /********* Lambda *********/
658 PyObject* args = nullptr;
659
660 /* Create function args */
661 if (cb_self) {
662 args = triton::bindings::python::xPyTuple_New(3);
663 PyTuple_SetItem(args, 0, cb_self);
664 PyTuple_SetItem(args, 1, triton::bindings::python::PyTritonContextRef(ctx));
665 PyTuple_SetItem(args, 2, triton::bindings::python::PyAstNode(node));
666 Py_INCREF(cb_self);
667 }
668 else {
669 args = triton::bindings::python::xPyTuple_New(2);
670 PyTuple_SetItem(args, 0, triton::bindings::python::PyTritonContextRef(ctx));
671 PyTuple_SetItem(args, 1, triton::bindings::python::PyAstNode(node));
672 }
673
674 /* Call the callback */
675 PyObject* ret = PyObject_CallObject(cb, args);
676
677 /* Release args */
678 Py_DECREF(args);
679
680 /* Check the call */
681 if (ret == nullptr) {
682 throw triton::exceptions::PyCallbacks();
683 }
684
685 /* Check if the callback has returned a AbstractNode */
686 if (!PyAstNode_Check(ret))
687 throw triton::exceptions::Callbacks("Callbacks::processCallbacks(SYMBOLIC_SIMPLIFICATION): You must return a AstNode object.");
688
689 /* Update node */
690 node = PyAstNode_AsAstNode(ret);
691 return node;
692 /********* End of lambda *********/
693 }, cb));
694 break;
695
696 default:
697 return PyErr_Format(PyExc_TypeError, "Callbacks::addCallback(): Invalid kind of callback.");
698 }
699 }
700 catch (const triton::exceptions::PyCallbacks&) {
701 return nullptr;
702 }
703 catch (const triton::exceptions::Exception& e) {
704 return PyErr_Format(PyExc_TypeError, "%s", e.what());
705 }
706
707 Py_INCREF(Py_None);
708 return Py_None;
709 }
710
711
712 static PyObject* TritonContext_assignSymbolicExpressionToMemory(PyObject* self, PyObject* args) {
713 PyObject* se = nullptr;
714 PyObject* mem = nullptr;
715
716 /* Extract arguments */
717 if (PyArg_ParseTuple(args, "|OO", &se, &mem) == false) {
718 return PyErr_Format(PyExc_TypeError, "TritonContext::assignSymbolicExpressionToMemory(): Invalid number of arguments");
719 }
720
721 if (se == nullptr || (!PySymbolicExpression_Check(se)))
722 return PyErr_Format(PyExc_TypeError, "TritonContext::assignSymbolicExpressionToMemory(): Expects a SymbolicExpression as first argument.");
723
724 if (mem == nullptr || (!PyMemoryAccess_Check(mem)))
725 return PyErr_Format(PyExc_TypeError, "TritonContext::assignSymbolicExpressionToMemory(): Expects a MemoryAccess as second argument.");
726
727 const triton::engines::symbolic::SharedSymbolicExpression& arg1 = PySymbolicExpression_AsSymbolicExpression(se);
728 triton::arch::MemoryAccess arg2 = *PyMemoryAccess_AsMemoryAccess(mem);
729
730 try {
731 PyTritonContext_AsTritonContext(self)->assignSymbolicExpressionToMemory(arg1, arg2);
732 }
733 catch (const triton::exceptions::PyCallbacks&) {
734 return nullptr;
735 }
736 catch (const triton::exceptions::Exception& e) {
737 return PyErr_Format(PyExc_TypeError, "%s", e.what());
738 }
739
740 Py_INCREF(Py_None);
741 return Py_None;
742 }
743
744
745 static PyObject* TritonContext_assignSymbolicExpressionToRegister(PyObject* self, PyObject* args) {
746 PyObject* se = nullptr;
747 PyObject* reg = nullptr;
748
749 /* Extract arguments */
750 if (PyArg_ParseTuple(args, "|OO", &se, &reg) == false) {
751 return PyErr_Format(PyExc_TypeError, "TritonContext::assignSymbolicExpressionToRegister(): Invalid number of arguments");
752 }
753
754 if (se == nullptr || (!PySymbolicExpression_Check(se)))
755 return PyErr_Format(PyExc_TypeError, "TritonContext::assignSymbolicExpressionToRegister(): Expects a SymbolicExpression as first argument.");
756
757 if (reg == nullptr || (!PyRegister_Check(reg)))
758 return PyErr_Format(PyExc_TypeError, "TritonContext::assignSymbolicExpressionToRegister(): Expects a Register as second argument.");
759
760 const triton::engines::symbolic::SharedSymbolicExpression& arg1 = PySymbolicExpression_AsSymbolicExpression(se);
761 triton::arch::Register arg2 = *PyRegister_AsRegister(reg);
762
763 try {
764 PyTritonContext_AsTritonContext(self)->assignSymbolicExpressionToRegister(arg1, arg2);
765 }
766 catch (const triton::exceptions::PyCallbacks&) {
767 return nullptr;
768 }
769 catch (const triton::exceptions::Exception& e) {
770 return PyErr_Format(PyExc_TypeError, "%s", e.what());
771 }
772
773 Py_INCREF(Py_None);
774 return Py_None;
775 }
776
777
778 static PyObject* TritonContext_buildSemantics(PyObject* self, PyObject* inst) {
779 if (!PyInstruction_Check(inst))
780 return PyErr_Format(PyExc_TypeError, "TritonContext::buildSemantics(): Expects an Instruction as argument.");
781
782 try {
783 return PyLong_FromUint32(PyTritonContext_AsTritonContext(self)->buildSemantics(*PyInstruction_AsInstruction(inst)));
784 }
785 catch (const triton::exceptions::PyCallbacks&) {
786 return nullptr;
787 }
788 catch (const triton::exceptions::Exception& e) {
789 return PyErr_Format(PyExc_TypeError, "%s", e.what());
790 }
791 }
792
793
794 static PyObject* TritonContext_clearCallbacks(PyObject* self, PyObject* noarg) {
795 try {
796 PyTritonContext_AsTritonContext(self)->clearCallbacks();
797 }
798 catch (const triton::exceptions::PyCallbacks&) {
799 return nullptr;
800 }
801 catch (const triton::exceptions::Exception& e) {
802 return PyErr_Format(PyExc_TypeError, "%s", e.what());
803 }
804
805 Py_INCREF(Py_None);
806 return Py_None;
807 }
808
809
810 static PyObject* TritonContext_clearModes(PyObject* self, PyObject* noarg) {
811 try {
812 PyTritonContext_AsTritonContext(self)->clearModes();
813 }
814 catch (const triton::exceptions::PyCallbacks&) {
815 return nullptr;
816 }
817 catch (const triton::exceptions::Exception& e) {
818 return PyErr_Format(PyExc_TypeError, "%s", e.what());
819 }
820
821 Py_INCREF(Py_None);
822 return Py_None;
823 }
824
825
826 static PyObject* TritonContext_clearConcreteMemoryValue(PyObject* self, PyObject* args) {
827 PyObject* baseAddr = nullptr;
828 PyObject* size = nullptr;
829
830 /* Extract arguments */
831 if (PyArg_ParseTuple(args, "|OO", &baseAddr, &size) == false) {
832 return PyErr_Format(PyExc_TypeError, "TritonContext::clearConcreteMemoryValue(): Invalid number of arguments");
833 }
834
835 try {
836 if (baseAddr && PyMemoryAccess_Check(baseAddr)) {
837 PyTritonContext_AsTritonContext(self)->clearConcreteMemoryValue(*PyMemoryAccess_AsMemoryAccess(baseAddr));
838 }
839 else if (baseAddr && (PyLong_Check(baseAddr) || PyInt_Check(baseAddr))) {
840 if (size && (PyLong_Check(size) || PyInt_Check(size))) {
841 PyTritonContext_AsTritonContext(self)->clearConcreteMemoryValue(PyLong_AsUint64(baseAddr), PyLong_AsUsize(size));
842 }
843 else {
844 return PyErr_Format(PyExc_TypeError, "TritonContext::clearConcreteMemoryValue(): Expects a size (integer) as second argument.");
845 }
846 }
847 else {
848 return PyErr_Format(PyExc_TypeError, "TritonContext::clearConcreteMemoryValue(): Expects a base address (integer) as arguments or a memory cells.");
849 }
850 }
851 catch (const triton::exceptions::PyCallbacks&) {
852 return nullptr;
853 }
854 catch (const triton::exceptions::Exception& e) {
855 return PyErr_Format(PyExc_TypeError, "%s", e.what());
856 }
857
858 Py_INCREF(Py_None);
859 return Py_None;
860 }
861
862
863 static PyObject* TritonContext_clearPathConstraints(PyObject* self, PyObject* noarg) {
864 try {
865 PyTritonContext_AsTritonContext(self)->clearPathConstraints();
866 }
867 catch (const triton::exceptions::Exception& e) {
868 return PyErr_Format(PyExc_TypeError, "%s", e.what());
869 }
870
871 Py_INCREF(Py_None);
872 return Py_None;
873 }
874
875
876 static PyObject* TritonContext_concretizeAllMemory(PyObject* self, PyObject* noarg) {
877 try {
878 PyTritonContext_AsTritonContext(self)->concretizeAllMemory();
879 }
880 catch (const triton::exceptions::PyCallbacks&) {
881 return nullptr;
882 }
883 catch (const triton::exceptions::Exception& e) {
884 return PyErr_Format(PyExc_TypeError, "%s", e.what());
885 }
886
887 Py_INCREF(Py_None);
888 return Py_None;
889 }
890
891
892 static PyObject* TritonContext_concretizeAllRegister(PyObject* self, PyObject* noarg) {
893 try {
894 PyTritonContext_AsTritonContext(self)->concretizeAllRegister();
895 }
896 catch (const triton::exceptions::PyCallbacks&) {
897 return nullptr;
898 }
899 catch (const triton::exceptions::Exception& e) {
900 return PyErr_Format(PyExc_TypeError, "%s", e.what());
901 }
902
903 Py_INCREF(Py_None);
904 return Py_None;
905 }
906
907
908 static PyObject* TritonContext_concretizeMemory(PyObject* self, PyObject* mem) {
909 /* If mem is an address */
910 if (PyLong_Check(mem) || PyInt_Check(mem)) {
911 try {
912 PyTritonContext_AsTritonContext(self)->concretizeMemory(PyLong_AsUint64(mem));
913 }
914 catch (const triton::exceptions::PyCallbacks&) {
915 return nullptr;
916 }
917 catch (const triton::exceptions::Exception& e) {
918 return PyErr_Format(PyExc_TypeError, "%s", e.what());
919 }
920 }
921
922 /* If mem is a MemoryAccess */
923 else if (PyMemoryAccess_Check(mem)) {
924 try {
925 PyTritonContext_AsTritonContext(self)->concretizeMemory(*PyMemoryAccess_AsMemoryAccess(mem));
926 }
927 catch (const triton::exceptions::PyCallbacks&) {
928 return nullptr;
929 }
930 catch (const triton::exceptions::Exception& e) {
931 return PyErr_Format(PyExc_TypeError, "%s", e.what());
932 }
933 }
934
935 /* Invalid parameter */
936 else
937 return PyErr_Format(PyExc_TypeError, "TritonContext::concretizeMemory(): Expects an integer or MemoryAccess as argument.");
938
939 Py_INCREF(Py_None);
940 return Py_None;
941 }
942
943
944 static PyObject* TritonContext_concretizeRegister(PyObject* self, PyObject* reg) {
945 if (!PyRegister_Check(reg))
946 return PyErr_Format(PyExc_TypeError, "TritonContext::concretizeRegister(): Expects a Register as argument.");
947
948 try {
949 PyTritonContext_AsTritonContext(self)->concretizeRegister(*PyRegister_AsRegister(reg));
950 }
951 catch (const triton::exceptions::PyCallbacks&) {
952 return nullptr;
953 }
954 catch (const triton::exceptions::Exception& e) {
955 return PyErr_Format(PyExc_TypeError, "%s", e.what());
956 }
957
958 Py_INCREF(Py_None);
959 return Py_None;
960 }
961
962
963 static PyObject* TritonContext_createSymbolicMemoryExpression(PyObject* self, PyObject* args) {
964 PyObject* inst = nullptr;
965 PyObject* node = nullptr;
966 PyObject* mem = nullptr;
967 PyObject* comment = nullptr;
968 std::string ccomment = "";
969
970 /* Extract arguments */
971 if (PyArg_ParseTuple(args, "|OOOO", &inst, &node, &mem, &comment) == false) {
972 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicMemoryExpression(): Invalid number of arguments");
973 }
974
975 if (inst == nullptr || (!PyInstruction_Check(inst)))
976 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicMemoryExpression(): Expects an Instruction as first argument.");
977
978 if (node == nullptr || (!PyAstNode_Check(node)))
979 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicMemoryExpression(): Expects a AstNode as second argument.");
980
981 if (mem == nullptr || (!PyMemoryAccess_Check(mem)))
982 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicMemoryExpression(): Expects a MemoryAccess as third argument.");
983
984 if (comment != nullptr && !PyStr_Check(comment))
985 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicMemoryExpression(): Expects a sting as fourth argument.");
986
987 if (comment != nullptr)
988 ccomment = PyStr_AsString(comment);
989
990 triton::arch::Instruction& arg1 = *PyInstruction_AsInstruction(inst);
991 triton::ast::SharedAbstractNode arg2 = PyAstNode_AsAstNode(node);
992 triton::arch::MemoryAccess arg3 = *PyMemoryAccess_AsMemoryAccess(mem);
993
994 try {
995 return PySymbolicExpression(PyTritonContext_AsTritonContext(self)->createSymbolicMemoryExpression(arg1, arg2, arg3, ccomment));
996 }
997 catch (const triton::exceptions::PyCallbacks&) {
998 return nullptr;
999 }
1000 catch (const triton::exceptions::Exception& e) {
1001 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1002 }
1003 }
1004
1005
1006 static PyObject* TritonContext_createSymbolicRegisterExpression(PyObject* self, PyObject* args) {
1007 PyObject* inst = nullptr;
1008 PyObject* node = nullptr;
1009 PyObject* reg = nullptr;
1010 PyObject* comment = nullptr;
1011 std::string ccomment = "";
1012
1013 /* Extract arguments */
1014 if (PyArg_ParseTuple(args, "|OOOO", &inst, &node, &reg, &comment) == false) {
1015 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicRegisterExpression(): Invalid number of arguments");
1016 }
1017
1018 if (inst == nullptr || (!PyInstruction_Check(inst)))
1019 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicRegisterExpression(): Expects an Instruction as first argument.");
1020
1021 if (node == nullptr || (!PyAstNode_Check(node)))
1022 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicRegisterExpression(): Expects a AstNode as second argument.");
1023
1024 if (reg == nullptr || (!PyRegister_Check(reg)))
1025 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicRegisterExpression(): Expects a Register as third argument.");
1026
1027 if (comment != nullptr && !PyStr_Check(comment))
1028 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicRegisterExpression(): Expects a sting as fourth argument.");
1029
1030 if (comment != nullptr)
1031 ccomment = PyStr_AsString(comment);
1032
1033 triton::arch::Instruction& arg1 = *PyInstruction_AsInstruction(inst);
1034 triton::ast::SharedAbstractNode arg2 = PyAstNode_AsAstNode(node);
1035 triton::arch::Register arg3 = *PyRegister_AsRegister(reg);
1036
1037 try {
1038 return PySymbolicExpression(PyTritonContext_AsTritonContext(self)->createSymbolicRegisterExpression(arg1, arg2, arg3, ccomment));
1039 }
1040 catch (const triton::exceptions::PyCallbacks&) {
1041 return nullptr;
1042 }
1043 catch (const triton::exceptions::Exception& e) {
1044 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1045 }
1046 }
1047
1048
1049 static PyObject* TritonContext_createSymbolicVolatileExpression(PyObject* self, PyObject* args) {
1050 PyObject* inst = nullptr;
1051 PyObject* node = nullptr;
1052 PyObject* comment = nullptr;
1053 std::string ccomment = "";
1054
1055 /* Extract arguments */
1056 if (PyArg_ParseTuple(args, "|OOO", &inst, &node, &comment) == false) {
1057 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicVolatileExpression(): Invalid number of arguments");
1058 }
1059
1060 if (inst == nullptr || (!PyInstruction_Check(inst)))
1061 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicVolatileExpression(): Expects an Instruction as first argument.");
1062
1063 if (node == nullptr || (!PyAstNode_Check(node)))
1064 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicVolatileExpression(): Expects a AstNode as second argument.");
1065
1066 if (comment != nullptr && !PyStr_Check(comment))
1067 return PyErr_Format(PyExc_TypeError, "TritonContext::createSymbolicVolatileExpression(): Expects a sting as third argument.");
1068
1069 if (comment != nullptr)
1070 ccomment = PyStr_AsString(comment);
1071
1072 triton::arch::Instruction& arg1 = *PyInstruction_AsInstruction(inst);
1073 triton::ast::SharedAbstractNode arg2 = PyAstNode_AsAstNode(node);
1074
1075 try {
1076 return PySymbolicExpression(PyTritonContext_AsTritonContext(self)->createSymbolicVolatileExpression(arg1, arg2, ccomment));
1077 }
1078 catch (const triton::exceptions::PyCallbacks&) {
1079 return nullptr;
1080 }
1081 catch (const triton::exceptions::Exception& e) {
1082 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1083 }
1084 }
1085
1086
1087 static PyObject* TritonContext_disassembly(PyObject* self, PyObject* args) {
1088 PyObject* arg0 = nullptr;
1089 PyObject* arg1 = nullptr;
1090 PyObject* ret = nullptr;
1091 triton::usize index = 0;
1092
1093 /* Extract arguments */
1094 if (PyArg_ParseTuple(args, "|OO", &arg0, &arg1) == false) {
1095 return PyErr_Format(PyExc_TypeError, "TritonContext::disassembly(): Invalid number of arguments.");
1096 }
1097
1098 try {
1099 if (arg0 != nullptr && PyInstruction_Check(arg0)) {
1100 PyTritonContext_AsTritonContext(self)->disassembly(*PyInstruction_AsInstruction(arg0));
1101 Py_INCREF(Py_None);
1102 return Py_None;
1103 }
1104 if (arg0 != nullptr && PyBasicBlock_Check(arg0)) {
1105 triton::uint64 base = 0;
1106 if (arg1 != nullptr && (PyLong_Check(arg1) || PyInt_Check(arg1))) {
1107 base = PyLong_AsUint64(arg1);
1108 }
1109 PyTritonContext_AsTritonContext(self)->disassembly(*PyBasicBlock_AsBasicBlock(arg0), base);
1110 Py_INCREF(Py_None);
1111 return Py_None;
1112 }
1113 if ((arg0 != nullptr && (PyLong_Check(arg0) || PyInt_Check(arg0))) &&
1114 (arg1 == nullptr || PyLong_Check(arg1) || PyInt_Check(arg1))) {
1115
1116 std::vector<triton::arch::Instruction> insts;
1117 if (arg1) {
1118 insts = PyTritonContext_AsTritonContext(self)->disassembly(PyLong_AsUint64(arg0), PyLong_AsUsize(arg1));
1119 ret = xPyList_New(insts.size());
1120 for (auto& inst : insts)
1121 PyList_SetItem(ret, index++, PyInstruction(inst));
1122 }
1123 else {
1124 ret = PyBasicBlock(PyTritonContext_AsTritonContext(self)->disassembly(PyLong_AsUint64(arg0)));
1125 }
1126 return ret;
1127 }
1128 else {
1129 return PyErr_Format(PyExc_TypeError, "TritonContext::disassembly(): Expects an Instruction or two integers as arguments.");
1130 }
1131 }
1132 catch (const triton::exceptions::PyCallbacks&) {
1133 return nullptr;
1134 }
1135 catch (const triton::exceptions::Exception& e) {
1136 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1137 }
1138 }
1139
1140
1141 static PyObject* TritonContext_evaluateAstViaSolver(PyObject* self, PyObject* node) {
1142 if (!PyAstNode_Check(node))
1143 return PyErr_Format(PyExc_TypeError, "TritonContext::evaluateAstViaSolver(): Expects a AstNode as argument.");
1144
1145 try {
1146 return PyLong_FromUint512(PyTritonContext_AsTritonContext(self)->evaluateAstViaSolver(PyAstNode_AsAstNode(node)));
1147 }
1148 catch (const triton::exceptions::PyCallbacks&) {
1149 return nullptr;
1150 }
1151 catch (const triton::exceptions::Exception& e) {
1152 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1153 }
1154
1155 Py_INCREF(Py_None);
1156 return Py_None;
1157 }
1158
1159
1160 static PyObject* TritonContext_getAllRegisters(PyObject* self, PyObject* noarg) {
1161 PyObject* ret = nullptr;
1162
1163 try {
1164 triton::uint32 index = 0;
1165 auto& regs = PyTritonContext_AsTritonContext(self)->getAllRegisters();
1166
1167 ret = xPyList_New(regs.size());
1168 for (auto& reg: regs)
1169 PyList_SetItem(ret, index++, PyRegister(reg.second));
1170 }
1171 catch (const triton::exceptions::PyCallbacks&) {
1172 return nullptr;
1173 }
1174 catch (const triton::exceptions::Exception& e) {
1175 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1176 }
1177
1178 return ret;
1179 }
1180
1181
1182 static PyObject* TritonContext_getArchitecture(PyObject* self, PyObject* noarg) {
1183 try {
1184 return PyLong_FromUint32(PyTritonContext_AsTritonContext(self)->getArchitecture());
1185 }
1186 catch (const triton::exceptions::PyCallbacks&) {
1187 return nullptr;
1188 }
1189 catch (const triton::exceptions::Exception& e) {
1190 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1191 }
1192 }
1193
1194
1195 static PyObject* TritonContext_getAstContext(PyObject* self, PyObject* noarg) {
1196 try {
1197 return PyAstContext(PyTritonContext_AsTritonContext(self)->getAstContext());
1198 }
1199 catch (const triton::exceptions::PyCallbacks&) {
1200 return nullptr;
1201 }
1202 catch (const triton::exceptions::Exception& e) {
1203 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1204 }
1205 }
1206
1207
1208 static PyObject* TritonContext_getAstRepresentationMode(PyObject* self, PyObject* noarg) {
1209 try {
1210 return PyLong_FromUint32(PyTritonContext_AsTritonContext(self)->getAstRepresentationMode());
1211 }
1212 catch (const triton::exceptions::PyCallbacks&) {
1213 return nullptr;
1214 }
1215 catch (const triton::exceptions::Exception& e) {
1216 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1217 }
1218 }
1219
1220
1221 static PyObject* TritonContext_getConcreteMemoryAreaValue(PyObject* self, PyObject* args, PyObject* kwargs) {
1222 triton::uint8* area = nullptr;
1223 PyObject* ret = nullptr;
1224 PyObject* addr = nullptr;
1225 PyObject* size = nullptr;
1226 PyObject* execCallbacks = nullptr;
1227
1228 static char* keywords[] = {
1229 (char*)"addr",
1230 (char*)"size",
1231 (char*)"callbacks",
1232 nullptr
1233 };
1234
1235 /* Extract keywords */
1236 if (PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O", keywords, &addr, &size, &execCallbacks) == false) {
1237 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteMemoryAreaValue(): Invalid keyword argument");
1238 }
1239
1240 if (addr == nullptr || (!PyLong_Check(addr) && !PyInt_Check(addr))) {
1241 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteMemoryAreaValue(): Expects an integer as addr keyword.");
1242 }
1243
1244 if (size == nullptr || (!PyLong_Check(size) && !PyInt_Check(size))) {
1245 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteMemoryAreaValue(): Expects an integer as size keyword.");
1246 }
1247
1248 if (execCallbacks != nullptr && !PyBool_Check(execCallbacks)) {
1249 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteMemoryAreaValue(): Expects a boolean as execCallbacks keyword.");
1250 }
1251
1252 if (execCallbacks == nullptr) {
1253 execCallbacks = PyLong_FromUint32(true);
1254 }
1255
1256 try {
1257 std::vector<triton::uint8> vv = PyTritonContext_AsTritonContext(self)->getConcreteMemoryAreaValue(PyLong_AsUint64(addr), PyLong_AsUsize(size), PyLong_AsBool(execCallbacks));
1258 area = new triton::uint8[vv.size()];
1259
1260 for (triton::usize index = 0; index < vv.size(); index++)
1261 area[index] = vv[index];
1262
1263 ret = PyBytes_FromStringAndSize(reinterpret_cast<const char*>(area), vv.size());
1264 delete[] area;
1265 return ret;
1266
1267 }
1268 catch (const triton::exceptions::PyCallbacks&) {
1269 return nullptr;
1270 }
1271 catch (const triton::exceptions::Exception& e) {
1272 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1273 }
1274
1275 return ret;
1276 }
1277
1278
1279 static PyObject* TritonContext_getConcreteMemoryValue(PyObject* self, PyObject* args, PyObject* kwargs) {
1280 PyObject* mem = nullptr;
1281 PyObject* execCallbacks = nullptr;
1282
1283 static char* keywords[] = {
1284 (char*)"mem",
1285 (char*)"callbacks",
1286 nullptr
1287 };
1288
1289 /* Extract keywords */
1290 if (PyArg_ParseTupleAndKeywords(args, kwargs, "O|O", keywords, &mem, &execCallbacks) == false) {
1291 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteMemoryValue(): Invalid keyword argument");
1292 }
1293
1294 if (mem == nullptr || (!PyLong_Check(mem) && !PyInt_Check(mem) && !PyMemoryAccess_Check(mem))) {
1295 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteMemoryValue(): Expects a MemoryAccess or an integer as mem keyword.");
1296 }
1297
1298 if (execCallbacks != nullptr && !PyBool_Check(execCallbacks)) {
1299 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteMemoryValue(): Expects a boolean as execCallbacks keyword.");
1300 }
1301
1302 if (execCallbacks == nullptr) {
1303 execCallbacks = PyLong_FromUint32(true);
1304 }
1305
1306 try {
1307 if (PyLong_Check(mem) || PyInt_Check(mem))
1308 return PyLong_FromUint512(PyTritonContext_AsTritonContext(self)->getConcreteMemoryValue(PyLong_AsUint64(mem), PyLong_AsBool(execCallbacks)));
1309 else if (PyMemoryAccess_Check(mem))
1310 return PyLong_FromUint512(PyTritonContext_AsTritonContext(self)->getConcreteMemoryValue(*PyMemoryAccess_AsMemoryAccess(mem), PyLong_AsBool(execCallbacks)));
1311 else
1312 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteMemoryValue(): Something wrong.");
1313 }
1314 catch (const triton::exceptions::PyCallbacks&) {
1315 return nullptr;
1316 }
1317 catch (const triton::exceptions::Exception& e) {
1318 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1319 }
1320 }
1321
1322
1323 static PyObject* TritonContext_getConcreteRegisterValue(PyObject* self, PyObject* args, PyObject* kwargs) {
1324 PyObject* reg = nullptr;
1325 PyObject* execCallbacks = nullptr;
1326
1327 static char* keywords[] = {
1328 (char*)"reg",
1329 (char*)"callbacks",
1330 nullptr
1331 };
1332
1333 /* Extract keywords */
1334 if (PyArg_ParseTupleAndKeywords(args, kwargs, "O|O", keywords, &reg, &execCallbacks) == false) {
1335 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteRegisterValue(): Invalid keyword argument");
1336 }
1337
1338 if (reg == nullptr || !PyRegister_Check(reg)) {
1339 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteRegisterValue(): Expects a Register as reg keyword.");
1340 }
1341
1342 if (execCallbacks != nullptr && !PyBool_Check(execCallbacks)) {
1343 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteRegisterValue(): Expects a boolean as execCallbacks keyword.");
1344 }
1345
1346 if (execCallbacks == nullptr) {
1347 execCallbacks = PyLong_FromUint32(true);
1348 }
1349
1350 try {
1351 return PyLong_FromUint512(PyTritonContext_AsTritonContext(self)->getConcreteRegisterValue(*PyRegister_AsRegister(reg), PyLong_AsBool(execCallbacks)));
1352 }
1353 catch (const triton::exceptions::PyCallbacks&) {
1354 return nullptr;
1355 }
1356 catch (const triton::exceptions::Exception& e) {
1357 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1358 }
1359 }
1360
1361
1362 static PyObject* TritonContext_getConcreteVariableValue(PyObject* self, PyObject* symVar) {
1363 if (!PySymbolicVariable_Check(symVar))
1364 return PyErr_Format(PyExc_TypeError, "TritonContext::getConcreteVariableValue(): Expects a SymbolicVariable as argument.");
1365
1366 try {
1367 return PyLong_FromUint512(PyTritonContext_AsTritonContext(self)->getConcreteVariableValue(PySymbolicVariable_AsSymbolicVariable(symVar)));
1368 }
1369 catch (const triton::exceptions::PyCallbacks&) {
1370 return nullptr;
1371 }
1372 catch (const triton::exceptions::Exception& e) {
1373 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1374 }
1375 }
1376
1377
1378 static PyObject* TritonContext_getGprBitSize(PyObject* self, PyObject* noarg) {
1379 try {
1380 return PyLong_FromUint32(PyTritonContext_AsTritonContext(self)->getGprBitSize());
1381 }
1382 catch (const triton::exceptions::PyCallbacks&) {
1383 return nullptr;
1384 }
1385 catch (const triton::exceptions::Exception& e) {
1386 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1387 }
1388 }
1389
1390
1391 static PyObject* TritonContext_getGprSize(PyObject* self, PyObject* noarg) {
1392 try {
1393 return PyLong_FromUint32(PyTritonContext_AsTritonContext(self)->getGprSize());
1394 }
1395 catch (const triton::exceptions::PyCallbacks&) {
1396 return nullptr;
1397 }
1398 catch (const triton::exceptions::Exception& e) {
1399 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1400 }
1401 }
1402
1403
1404 static PyObject* TritonContext_getImmediateAst(PyObject* self, PyObject* imm) {
1405 if (!PyImmediate_Check(imm))
1406 return PyErr_Format(PyExc_TypeError, "TritonContext::getImmediateAst(): Expects an Immediate as argument.");
1407
1408 try {
1409 return PyAstNode(PyTritonContext_AsTritonContext(self)->getImmediateAst(*PyImmediate_AsImmediate(imm)));
1410 }
1411 catch (const triton::exceptions::PyCallbacks&) {
1412 return nullptr;
1413 }
1414 catch (const triton::exceptions::Exception& e) {
1415 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1416 }
1417 }
1418
1419
1420 static PyObject* TritonContext_getMemoryAst(PyObject* self, PyObject* mem) {
1421 if (!PyMemoryAccess_Check(mem))
1422 return PyErr_Format(PyExc_TypeError, "TritonContext::getMemoryAst(): Expects an MemoryAccess as argument.");
1423
1424 try {
1425 return PyAstNode(PyTritonContext_AsTritonContext(self)->getMemoryAst(*PyMemoryAccess_AsMemoryAccess(mem)));
1426 }
1427 catch (const triton::exceptions::PyCallbacks&) {
1428 return nullptr;
1429 }
1430 catch (const triton::exceptions::Exception& e) {
1431 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1432 }
1433 }
1434
1435
1436 static PyObject* TritonContext_getModel(PyObject* self, PyObject* args, PyObject* kwargs) {
1437 triton::engines::solver::status_e status;
1438 triton::uint32 solvingTime = 0;
1439 triton::uint32 timeout_c = 0;
1440
1441 PyObject* dict = nullptr;
1442 PyObject* node = nullptr;
1443 PyObject* wb = nullptr;
1444 PyObject* timeout = nullptr;
1445
1446 static char* keywords[] = {
1447 (char*)"node",
1448 (char*)"status",
1449 (char*)"timeout",
1450 nullptr
1451 };
1452
1453 /* Extract Keywords */
1454 if (PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO", keywords, &node, &wb, &timeout) == false) {
1455 return PyErr_Format(PyExc_TypeError, "TritonContext::getModel(): Invalid keyword argument.");
1456 }
1457
1458 if (node == nullptr || !PyAstNode_Check(node)) {
1459 return PyErr_Format(PyExc_TypeError, "TritonContext::getModel(): Expects a AstNode as node argument.");
1460 }
1461
1462 if (wb != nullptr && !PyBool_Check(wb)) {
1463 return PyErr_Format(PyExc_TypeError, "TritonContext::getModel(): Expects a boolean as status keyword.");
1464 }
1465
1466 if (timeout != nullptr && (!PyLong_Check(timeout) && !PyInt_Check(timeout))) {
1467 return PyErr_Format(PyExc_TypeError, "TritonContext::getModel(): Expects a integer as timeout keyword.");
1468 }
1469
1470 if (timeout != nullptr) {
1471 timeout_c = PyLong_AsUint32(timeout);
1472 }
1473
1474 try {
1475 dict = triton::bindings::python::xPyDict_New();
1476 auto model = PyTritonContext_AsTritonContext(self)->getModel(PyAstNode_AsAstNode(node), &status, timeout_c, &solvingTime);
1477 for (auto it = model.begin(); it != model.end(); it++) {
1478 xPyDict_SetItem(dict, PyLong_FromUsize(it->first), PySolverModel(it->second));
1479 }
1480 }
1481 catch (const triton::exceptions::PyCallbacks&) {
1482 return nullptr;
1483 }
1484 catch (const triton::exceptions::Exception& e) {
1485 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1486 }
1487
1488 if (wb != nullptr && PyLong_AsBool(wb) == true) {
1489 PyObject* tuple = triton::bindings::python::xPyTuple_New(3);
1490 PyTuple_SetItem(tuple, 0, dict);
1491 PyTuple_SetItem(tuple, 1, PyLong_FromUint32(status));
1492 PyTuple_SetItem(tuple, 2, PyLong_FromUint32(solvingTime));
1493 return tuple;
1494 }
1495
1496 return dict;
1497 }
1498
1499
1500 static PyObject* TritonContext_getModels(PyObject* self, PyObject* args, PyObject* kwargs) {
1501 triton::engines::solver::status_e status;
1502 triton::uint32 solvingTime = 0;
1503 triton::uint32 timeout_c = 0;
1504
1505 PyObject* ret = nullptr;
1506 PyObject* node = nullptr;
1507 PyObject* limit = nullptr;
1508 PyObject* wb = nullptr;
1509 PyObject* timeout = nullptr;
1510
1511 static char* keywords[] = {
1512 (char*)"node",
1513 (char*)"limit",
1514 (char*)"status",
1515 (char*)"timeout",
1516 nullptr
1517 };
1518
1519 /* Extract Keywords */
1520 if (PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO", keywords, &node, &limit, &wb, &timeout) == false) {
1521 return PyErr_Format(PyExc_TypeError, "TritonContext::getModels(): Invalid keyword argument.");
1522 }
1523
1524 if (node == nullptr || !PyAstNode_Check(node)) {
1525 return PyErr_Format(PyExc_TypeError, "TritonContext::getModels(): Expects a AstNode as node argument.");
1526 }
1527
1528 if (limit == nullptr || (!PyLong_Check(limit) && !PyInt_Check(limit))) {
1529 return PyErr_Format(PyExc_TypeError, "TritonContext::getModels(): Expects an integer as limit argument.");
1530 }
1531
1532 if (wb != nullptr && !PyBool_Check(wb)) {
1533 return PyErr_Format(PyExc_TypeError, "TritonContext::getModels(): Expects a boolean as status keyword.");
1534 }
1535
1536 if (timeout != nullptr && (!PyLong_Check(timeout) && !PyInt_Check(timeout))) {
1537 return PyErr_Format(PyExc_TypeError, "TritonContext::getModels(): Expects a integer as timeout keyword.");
1538 }
1539
1540 if (timeout != nullptr) {
1541 timeout_c = PyLong_AsUint32(timeout);
1542 }
1543
1544 try {
1545 auto models = PyTritonContext_AsTritonContext(self)->getModels(PyAstNode_AsAstNode(node), PyLong_AsUint32(limit), &status, timeout_c, &solvingTime);
1546 triton::uint32 index = 0;
1547
1548 ret = xPyList_New(models.size());
1549 for (auto it = models.begin(); it != models.end(); it++) {
1550 PyObject* mdict = xPyDict_New();
1551 auto model = *it;
1552
1553 for (auto it2 = model.begin(); it2 != model.end(); it2++) {
1554 xPyDict_SetItem(mdict, PyLong_FromUsize(it2->first), PySolverModel(it2->second));
1555 }
1556 if (model.size() > 0)
1557 PyList_SetItem(ret, index++, mdict);
1558 }
1559 }
1560 catch (const triton::exceptions::PyCallbacks&) {
1561 return nullptr;
1562 }
1563 catch (const triton::exceptions::Exception& e) {
1564 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1565 }
1566
1567 if (wb != nullptr && PyLong_AsBool(wb) == true) {
1568 PyObject* tuple = triton::bindings::python::xPyTuple_New(3);
1569 PyTuple_SetItem(tuple, 0, ret);
1570 PyTuple_SetItem(tuple, 1, PyLong_FromUint32(status));
1571 PyTuple_SetItem(tuple, 2, PyLong_FromUint32(solvingTime));
1572 return tuple;
1573 }
1574
1575 return ret;
1576 }
1577
1578
1579 static PyObject* TritonContext_getParentRegisters(PyObject* self, PyObject* noarg) {
1580 PyObject* ret = nullptr;
1581
1582 try {
1583 triton::uint32 index = 0;
1584 auto regs = PyTritonContext_AsTritonContext(self)->getParentRegisters();
1585
1586 ret = xPyList_New(regs.size());
1587 for (const auto* reg: regs) {
1588 PyList_SetItem(ret, index++, PyRegister(*reg));
1589 }
1590 }
1591 catch (const triton::exceptions::PyCallbacks&) {
1592 return nullptr;
1593 }
1594 catch (const triton::exceptions::Exception& e) {
1595 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1596 }
1597
1598 return ret;
1599 }
1600
1601
1602 static PyObject* TritonContext_getPathConstraints(PyObject* self, PyObject* noarg) {
1603 PyObject* ret = nullptr;
1604
1605 try {
1606 triton::uint32 index = 0;
1607 const auto& pc = PyTritonContext_AsTritonContext(self)->getPathConstraints();
1608
1609 ret = xPyList_New(pc.size());
1610 for (auto it = pc.begin(); it != pc.end(); it++) {
1611 PyList_SetItem(ret, index++, PyPathConstraint(*it));
1612 }
1613 }
1614 catch (const triton::exceptions::PyCallbacks&) {
1615 return nullptr;
1616 }
1617 catch (const triton::exceptions::Exception& e) {
1618 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1619 }
1620
1621 return ret;
1622 }
1623
1624
1625 static PyObject* TritonContext_getPathPredicate(PyObject* self, PyObject* noarg) {
1626 try {
1627 return PyAstNode(PyTritonContext_AsTritonContext(self)->getPathPredicate());
1628 }
1629 catch (const triton::exceptions::PyCallbacks&) {
1630 return nullptr;
1631 }
1632 catch (const triton::exceptions::Exception& e) {
1633 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1634 }
1635 }
1636
1637
1638 static PyObject* TritonContext_getPathPredicateSize(PyObject* self, PyObject* noarg) {
1639 try {
1640 const auto& pc = PyTritonContext_AsTritonContext(self)->getPathConstraints();
1641 return PyLong_FromUsize(pc.size());
1642 }
1643 catch (const triton::exceptions::PyCallbacks&) {
1644 return nullptr;
1645 }
1646 catch (const triton::exceptions::Exception& e) {
1647 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1648 }
1649 }
1650
1651
1652 static PyObject* TritonContext_getPredicatesToReachAddress(PyObject* self, PyObject* addr) {
1653 PyObject* ret = nullptr;
1654
1655 if (addr == nullptr || (!PyLong_Check(addr) && !PyInt_Check(addr)))
1656 return PyErr_Format(PyExc_TypeError, "TritonContext::getPredicatesToReachAddress(): Expects an address as argument.");
1657
1658 try {
1659 triton::uint32 index = 0;
1660 auto preds = PyTritonContext_AsTritonContext(self)->getPredicatesToReachAddress(PyLong_AsUint64(addr));
1661
1662 ret = xPyList_New(preds.size());
1663 for (auto it = preds.begin(); it != preds.end(); it++) {
1664 PyList_SetItem(ret, index++, PyAstNode(*it));
1665 }
1666 }
1667 catch (const triton::exceptions::PyCallbacks&) {
1668 return nullptr;
1669 }
1670 catch (const triton::exceptions::Exception& e) {
1671 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1672 }
1673
1674 return ret;
1675 }
1676
1677
1678 static PyObject* TritonContext_getRegister(PyObject* self, PyObject* regIn) {
1679 try {
1680 if (regIn != nullptr && (PyLong_Check(regIn) || PyInt_Check(regIn))) {
1681 triton::arch::register_e rid = static_cast<triton::arch::register_e>(PyLong_AsUint32(regIn));
1682 triton::arch::Register regOut(PyTritonContext_AsTritonContext(self)->getRegister(rid));
1683 return PyRegister(regOut);
1684 }
1685
1686 else if (regIn != nullptr && (PyStr_Check(regIn))) {
1687 std::string name = std::string(PyStr_AsString(regIn));
1688 triton::arch::Register regOut(PyTritonContext_AsTritonContext(self)->getRegister(name));
1689 return PyRegister(regOut);
1690 }
1691
1692 else {
1693 return PyErr_Format(PyExc_TypeError, "TritonContext::getRegister(): Expects an integer or a string as argument.");
1694 }
1695 }
1696 catch (const triton::exceptions::PyCallbacks&) {
1697 return nullptr;
1698 }
1699 catch (const triton::exceptions::Exception& e) {
1700 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1701 }
1702 }
1703
1704
1705 static PyObject* TritonContext_getRegisterAst(PyObject* self, PyObject* reg) {
1706 if (!PyRegister_Check(reg))
1707 return PyErr_Format(PyExc_TypeError, "TritonContext::getRegisterAst(): Expects an Register as argument.");
1708
1709 try {
1710 return PyAstNode(PyTritonContext_AsTritonContext(self)->getRegisterAst(*PyRegister_AsRegister(reg)));
1711 }
1712 catch (const triton::exceptions::PyCallbacks&) {
1713 return nullptr;
1714 }
1715 catch (const triton::exceptions::Exception& e) {
1716 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1717 }
1718 }
1719
1720
1721 static PyObject* TritonContext_getSolver(PyObject* self, PyObject* noarg) {
1722 try {
1723 return PyLong_FromUint32(PyTritonContext_AsTritonContext(self)->getSolver());
1724 }
1725 catch (const triton::exceptions::PyCallbacks&) {
1726 return nullptr;
1727 }
1728 catch (const triton::exceptions::Exception& e) {
1729 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1730 }
1731 }
1732
1733
1734 static PyObject* TritonContext_getSymbolicExpression(PyObject* self, PyObject* symExprId) {
1735 if (!PyLong_Check(symExprId) && !PyInt_Check(symExprId))
1736 return PyErr_Format(PyExc_TypeError, "TritonContext::getSymbolicExpression(): Expects an integer as argument.");
1737
1738 try {
1739 return PySymbolicExpression(PyTritonContext_AsTritonContext(self)->getSymbolicExpression(PyLong_AsUsize(symExprId)));
1740 }
1741 catch (const triton::exceptions::PyCallbacks&) {
1742 return nullptr;
1743 }
1744 catch (const triton::exceptions::Exception& e) {
1745 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1746 }
1747 }
1748
1749
1750 static PyObject* TritonContext_getSymbolicExpressions(PyObject* self, PyObject* noarg) {
1751 PyObject* ret = nullptr;
1752
1753 try {
1754 const auto& expressions = PyTritonContext_AsTritonContext(self)->getSymbolicExpressions();
1755
1756 ret = xPyDict_New();
1757 for (auto it = expressions.begin(); it != expressions.end(); it++)
1758 xPyDict_SetItem(ret, PyLong_FromUsize(it->first), PySymbolicExpression(it->second));
1759 }
1760 catch (const triton::exceptions::PyCallbacks&) {
1761 return nullptr;
1762 }
1763 catch (const triton::exceptions::Exception& e) {
1764 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1765 }
1766
1767 return ret;
1768 }
1769
1770
1771 static PyObject* TritonContext_getSymbolicMemory(PyObject* self, PyObject* args) {
1772 PyObject* ret = nullptr;
1773 PyObject* addr = nullptr;
1774
1775 /* Extract arguments */
1776 if (PyArg_ParseTuple(args, "|O", &addr) == false) {
1777 return PyErr_Format(PyExc_TypeError, "TritonContext::getSymbolicMemory(): Invalid number of arguments");
1778 }
1779
1780 try {
1781 if (addr == nullptr) {
1782 auto regs = PyTritonContext_AsTritonContext(self)->getSymbolicMemory();
1783
1784 ret = xPyDict_New();
1785 for (auto it = regs.begin(); it != regs.end(); it++) {
1786 xPyDict_SetItem(ret, PyLong_FromUint64(it->first), PySymbolicExpression(it->second));
1787 }
1788 }
1789 else if (addr != nullptr && (PyLong_Check(addr) || PyInt_Check(addr))) {
1790 ret = PySymbolicExpression(PyTritonContext_AsTritonContext(self)->getSymbolicMemory(PyLong_AsUint64(addr)));
1791 }
1792 else
1793 return PyErr_Format(PyExc_TypeError, "TritonContext::getSymbolicMemory(): Expects an integer or nothing as argument.");
1794 }
1795 catch (const triton::exceptions::PyCallbacks&) {
1796 return nullptr;
1797 }
1798 catch (const triton::exceptions::Exception& e) {
1799 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1800 }
1801
1802 return ret;
1803 }
1804
1805
1806 static PyObject* TritonContext_getSymbolicMemoryValue(PyObject* self, PyObject* mem) {
1807 if (!PyLong_Check(mem) && !PyInt_Check(mem) && !PyMemoryAccess_Check(mem))
1808 return PyErr_Format(PyExc_TypeError, "TritonContext::getSymbolicMemoryValue(): Expects an integer or a MemoryAccess as argument.");
1809
1810 try {
1811 if (PyLong_Check(mem) || PyInt_Check(mem))
1812 return PyLong_FromUint512(PyTritonContext_AsTritonContext(self)->getSymbolicMemoryValue(PyLong_AsUint64(mem)));
1813 return PyLong_FromUint512(PyTritonContext_AsTritonContext(self)->getSymbolicMemoryValue(*PyMemoryAccess_AsMemoryAccess(mem)));
1814 }
1815 catch (const triton::exceptions::PyCallbacks&) {
1816 return nullptr;
1817 }
1818 catch (const triton::exceptions::Exception& e) {
1819 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1820 }
1821 }
1822
1823
1824 static PyObject* TritonContext_getSymbolicRegisters(PyObject* self, PyObject* noarg) {
1825 PyObject* ret = nullptr;
1826
1827 try {
1828 auto regs = PyTritonContext_AsTritonContext(self)->getSymbolicRegisters();
1829
1830 ret = xPyDict_New();
1831 for (auto it = regs.begin(); it != regs.end(); it++) {
1832 xPyDict_SetItem(ret, PyLong_FromUint64(it->first), PySymbolicExpression(it->second));
1833 }
1834 }
1835 catch (const triton::exceptions::PyCallbacks&) {
1836 return nullptr;
1837 }
1838 catch (const triton::exceptions::Exception& e) {
1839 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1840 }
1841
1842 return ret;
1843 }
1844
1845
1846 static PyObject* TritonContext_getSymbolicRegister(PyObject* self, PyObject* reg) {
1847 if (!PyRegister_Check(reg))
1848 return PyErr_Format(PyExc_TypeError, "TritonContext::getSymbolicRegister(): Expects a Register as argument.");
1849
1850 try {
1851 return PySymbolicExpression(PyTritonContext_AsTritonContext(self)->getSymbolicRegister(*PyRegister_AsRegister(reg)));
1852 }
1853 catch (const triton::exceptions::PyCallbacks&) {
1854 return nullptr;
1855 }
1856 catch (const triton::exceptions::Exception& e) {
1857 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1858 }
1859 }
1860
1861
1862 static PyObject* TritonContext_getSymbolicRegisterValue(PyObject* self, PyObject* reg) {
1863 if (!PyRegister_Check(reg))
1864 return PyErr_Format(PyExc_TypeError, "TritonContext::getSymbolicRegisterValue(): Expects a Register as argument.");
1865
1866 try {
1867 return PyLong_FromUint512(PyTritonContext_AsTritonContext(self)->getSymbolicRegisterValue(*PyRegister_AsRegister(reg)));
1868 }
1869 catch (const triton::exceptions::PyCallbacks&) {
1870 return nullptr;
1871 }
1872 catch (const triton::exceptions::Exception& e) {
1873 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1874 }
1875 }
1876
1877
1878 static PyObject* TritonContext_getSymbolicVariable(PyObject* self, PyObject* arg) {
1879 try {
1880 if (PyLong_Check(arg) || PyInt_Check(arg))
1881 return PySymbolicVariable(PyTritonContext_AsTritonContext(self)->getSymbolicVariable(PyLong_AsUsize(arg)));
1882
1883 else if (PyStr_Check(arg))
1884 return PySymbolicVariable(PyTritonContext_AsTritonContext(self)->getSymbolicVariable(PyStr_AsString(arg)));
1885
1886 else
1887 return PyErr_Format(PyExc_TypeError, "TritonContext::getSymbolicVariable(): Expects an integer or a string as argument.");
1888 }
1889 catch (const triton::exceptions::PyCallbacks&) {
1890 return nullptr;
1891 }
1892 catch (const triton::exceptions::Exception& e) {
1893 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1894 }
1895 }
1896
1897
1898 static PyObject* TritonContext_getSymbolicVariables(PyObject* self, PyObject* noarg) {
1899 PyObject* ret = nullptr;
1900
1901 try {
1902 const auto& variables = PyTritonContext_AsTritonContext(self)->getSymbolicVariables();
1903
1904 ret = xPyDict_New();
1905 for (auto sv: variables)
1906 xPyDict_SetItem(ret, PyLong_FromUsize(sv.first), PySymbolicVariable(sv.second));
1907 }
1908 catch (const triton::exceptions::PyCallbacks&) {
1909 return nullptr;
1910 }
1911 catch (const triton::exceptions::Exception& e) {
1912 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1913 }
1914
1915 return ret;
1916 }
1917
1918
1919 static PyObject* TritonContext_getTaintedMemory(PyObject* self, PyObject* noarg) {
1920 PyObject* ret = nullptr;
1921 triton::usize size = 0, index = 0;
1922
1923 try {
1924 std::unordered_set<triton::uint64> addresses = PyTritonContext_AsTritonContext(self)->getTaintedMemory();
1925
1926 size = addresses.size();
1927 ret = xPyList_New(size);
1928 for (auto it = addresses.begin(); it != addresses.end(); it++) {
1929 PyList_SetItem(ret, index, PyLong_FromUint64(*it));
1930 index++;
1931 }
1932 }
1933 catch (const triton::exceptions::PyCallbacks&) {
1934 return nullptr;
1935 }
1936 catch (const triton::exceptions::Exception& e) {
1937 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1938 }
1939
1940 return ret;
1941 }
1942
1943
1944 static PyObject* TritonContext_getTaintedRegisters(PyObject* self, PyObject* noarg) {
1945 PyObject* ret = nullptr;
1946 triton::usize size = 0, index = 0;
1947
1948 try {
1949 std::unordered_set<const triton::arch::Register*> registers = PyTritonContext_AsTritonContext(self)->getTaintedRegisters();
1950
1951 size = registers.size();
1952 ret = xPyList_New(size);
1953 for (const auto* reg: registers) {
1954 PyList_SetItem(ret, index, PyRegister(*reg));
1955 index++;
1956 }
1957 }
1958 catch (const triton::exceptions::PyCallbacks&) {
1959 return nullptr;
1960 }
1961 catch (const triton::exceptions::Exception& e) {
1962 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1963 }
1964
1965 return ret;
1966 }
1967
1968
1969 static PyObject* TritonContext_getTaintedSymbolicExpressions(PyObject* self, PyObject* noarg) {
1970 PyObject* ret = nullptr;
1971 triton::usize size = 0, index = 0;
1972
1973 try {
1974 auto expressions = PyTritonContext_AsTritonContext(self)->getTaintedSymbolicExpressions();
1975
1976 size = expressions.size();
1977 ret = xPyList_New(size);
1978 for (auto it = expressions.begin(); it != expressions.end(); it++) {
1979 PyList_SetItem(ret, index, PySymbolicExpression(*it));
1980 index++;
1981 }
1982 }
1983 catch (const triton::exceptions::PyCallbacks&) {
1984 return nullptr;
1985 }
1986 catch (const triton::exceptions::Exception& e) {
1987 return PyErr_Format(PyExc_TypeError, "%s", e.what());
1988 }
1989
1990 return ret;
1991 }
1992
1993
1994 static PyObject* TritonContext_initLeaAst(PyObject* self, PyObject* mem) {
1995 try {
1996 if (PyMemoryAccess_Check(mem)) {
1997 PyTritonContext_AsTritonContext(self)->initLeaAst(*PyMemoryAccess_AsMemoryAccess(mem), true);
1998 }
1999 else
2000 return PyErr_Format(PyExc_TypeError, "TritonContext::initLeaAst(): Expects a MemoryAccess as argument.");
2001 }
2002 catch (const triton::exceptions::PyCallbacks&) {
2003 return nullptr;
2004 }
2005 catch (const triton::exceptions::Exception& e) {
2006 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2007 }
2008
2009 Py_INCREF(Py_None);
2010 return Py_None;
2011 }
2012
2013
2014 static PyObject* TritonContext_isArchitectureValid(PyObject* self, PyObject* noarg) {
2015 try {
2016 if (PyTritonContext_AsTritonContext(self)->isArchitectureValid() == true)
2017 Py_RETURN_TRUE;
2018 Py_RETURN_FALSE;
2019 }
2020 catch (const triton::exceptions::PyCallbacks&) {
2021 return nullptr;
2022 }
2023 catch (const triton::exceptions::Exception& e) {
2024 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2025 }
2026 }
2027
2028
2029 static PyObject* TritonContext_isConcreteMemoryValueDefined(PyObject* self, PyObject* args) {
2030 PyObject* baseAddr = nullptr;
2031 PyObject* size = nullptr;
2032
2033 /* Extract arguments */
2034 if (PyArg_ParseTuple(args, "|OO", &baseAddr, &size) == false) {
2035 return PyErr_Format(PyExc_TypeError, "TritonContext::isConcreteMemoryValueDefined(): Invalid number of arguments");
2036 }
2037
2038 try {
2039 if (baseAddr && PyMemoryAccess_Check(baseAddr)) {
2040 if (PyTritonContext_AsTritonContext(self)->isConcreteMemoryValueDefined(*PyMemoryAccess_AsMemoryAccess(baseAddr)) == true)
2041 Py_RETURN_TRUE;
2042 Py_RETURN_FALSE;
2043 }
2044 else if (baseAddr && (PyLong_Check(baseAddr) || PyInt_Check(baseAddr))) {
2045 if (size && (PyLong_Check(size) || PyInt_Check(size))) {
2046 if (PyTritonContext_AsTritonContext(self)->isConcreteMemoryValueDefined(PyLong_AsUint64(baseAddr), PyLong_AsUsize(size)) == true)
2047 Py_RETURN_TRUE;
2048 Py_RETURN_FALSE;
2049 }
2050 else {
2051 return PyErr_Format(PyExc_TypeError, "TritonContext::isConcreteMemoryValueDefined(): Expects a size (integer) as second argument.");
2052 }
2053 }
2054 else {
2055 return PyErr_Format(PyExc_TypeError, "TritonContext::isConcreteMemoryValueDefined(): Expects a base address (integer) as arguments or a memory cells.");
2056 }
2057 }
2058 catch (const triton::exceptions::PyCallbacks&) {
2059 return nullptr;
2060 }
2061 catch (const triton::exceptions::Exception& e) {
2062 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2063 }
2064 }
2065
2066
2067 static PyObject* TritonContext_isFlag(PyObject* self, PyObject* reg) {
2068 if (!PyRegister_Check(reg))
2069 return PyErr_Format(PyExc_TypeError, "TritonContext::isFlag(): Expects a Register as argument.");
2070
2071 try {
2072 if (PyTritonContext_AsTritonContext(self)->isFlag(*PyRegister_AsRegister(reg)) == true)
2073 Py_RETURN_TRUE;
2074 Py_RETURN_FALSE;
2075 }
2076 catch (const triton::exceptions::PyCallbacks&) {
2077 return nullptr;
2078 }
2079 catch (const triton::exceptions::Exception& e) {
2080 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2081 }
2082 }
2083
2084
2085 static PyObject* TritonContext_isMemorySymbolized(PyObject* self, PyObject* mem) {
2086 try {
2087 if (PyMemoryAccess_Check(mem)) {
2088 if (PyTritonContext_AsTritonContext(self)->isMemorySymbolized(*PyMemoryAccess_AsMemoryAccess(mem)) == true)
2089 Py_RETURN_TRUE;
2090 }
2091
2092 else if (PyLong_Check(mem) || PyInt_Check(mem)) {
2093 if (PyTritonContext_AsTritonContext(self)->isMemorySymbolized(PyLong_AsUint64(mem)) == true)
2094 Py_RETURN_TRUE;
2095 }
2096
2097 else
2098 return PyErr_Format(PyExc_TypeError, "TritonContext::isMemorySymbolized(): Expects a MemoryAccess or an integer as argument.");
2099 }
2100 catch (const triton::exceptions::PyCallbacks&) {
2101 return nullptr;
2102 }
2103 catch (const triton::exceptions::Exception& e) {
2104 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2105 }
2106
2107 Py_RETURN_FALSE;
2108 }
2109
2110
2111 static PyObject* TritonContext_isMemoryTainted(PyObject* self, PyObject* mem) {
2112 try {
2113 if (PyMemoryAccess_Check(mem)) {
2114 if (PyTritonContext_AsTritonContext(self)->isMemoryTainted(*PyMemoryAccess_AsMemoryAccess(mem)) == true)
2115 Py_RETURN_TRUE;
2116 }
2117
2118 else if (PyLong_Check(mem) || PyInt_Check(mem)) {
2119 if (PyTritonContext_AsTritonContext(self)->isMemoryTainted(PyLong_AsUint64(mem)) == true)
2120 Py_RETURN_TRUE;
2121 }
2122
2123 else
2124 return PyErr_Format(PyExc_TypeError, "TritonContext::isMemoryTainted(): Expects a MemoryAccess or an integer as argument.");
2125 }
2126 catch (const triton::exceptions::PyCallbacks&) {
2127 return nullptr;
2128 }
2129 catch (const triton::exceptions::Exception& e) {
2130 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2131 }
2132
2133 Py_RETURN_FALSE;
2134 }
2135
2136
2137 static PyObject* TritonContext_isRegister(PyObject* self, PyObject* reg) {
2138 if (!PyRegister_Check(reg))
2139 return PyErr_Format(PyExc_TypeError, "TritonContext::isRegister(): Expects a Register as argument.");
2140
2141 try {
2142 if (PyTritonContext_AsTritonContext(self)->isRegister(*PyRegister_AsRegister(reg)) == true)
2143 Py_RETURN_TRUE;
2144 Py_RETURN_FALSE;
2145 }
2146 catch (const triton::exceptions::PyCallbacks&) {
2147 return nullptr;
2148 }
2149 catch (const triton::exceptions::Exception& e) {
2150 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2151 }
2152 }
2153
2154
2155 static PyObject* TritonContext_isRegisterSymbolized(PyObject* self, PyObject* reg) {
2156 if (!PyRegister_Check(reg))
2157 return PyErr_Format(PyExc_TypeError, "TritonContext::isRegisterSymbolized(): Expects a Register as argument.");
2158
2159 try {
2160 if (PyTritonContext_AsTritonContext(self)->isRegisterSymbolized(*PyRegister_AsRegister(reg)) == true)
2161 Py_RETURN_TRUE;
2162 Py_RETURN_FALSE;
2163 }
2164 catch (const triton::exceptions::PyCallbacks&) {
2165 return nullptr;
2166 }
2167 catch (const triton::exceptions::Exception& e) {
2168 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2169 }
2170 }
2171
2172
2173 static PyObject* TritonContext_isRegisterTainted(PyObject* self, PyObject* reg) {
2174 if (!PyRegister_Check(reg))
2175 return PyErr_Format(PyExc_TypeError, "TritonContext::isRegisterTainted(): Expects a Register as argument.");
2176
2177 try {
2178 if (PyTritonContext_AsTritonContext(self)->isRegisterTainted(*PyRegister_AsRegister(reg)) == true)
2179 Py_RETURN_TRUE;
2180 Py_RETURN_FALSE;
2181 }
2182 catch (const triton::exceptions::PyCallbacks&) {
2183 return nullptr;
2184 }
2185 catch (const triton::exceptions::Exception& e) {
2186 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2187 }
2188 }
2189
2190
2191 static PyObject* TritonContext_isRegisterValid(PyObject* self, PyObject* reg) {
2192 if (!PyRegister_Check(reg))
2193 return PyErr_Format(PyExc_TypeError, "TritonContext::isRegisterValid(): Expects a Register as argument.");
2194
2195 try {
2196 if (PyTritonContext_AsTritonContext(self)->isRegisterValid(*PyRegister_AsRegister(reg)) == true)
2197 Py_RETURN_TRUE;
2198 Py_RETURN_FALSE;
2199 }
2200 catch (const triton::exceptions::PyCallbacks&) {
2201 return nullptr;
2202 }
2203 catch (const triton::exceptions::Exception& e) {
2204 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2205 }
2206 }
2207
2208
2209 static PyObject* TritonContext_isSat(PyObject* self, PyObject* node) {
2210 if (!PyAstNode_Check(node))
2211 return PyErr_Format(PyExc_TypeError, "TritonContext::isSat(): Expects a AstNode as argument.");
2212
2213 try {
2214 if (PyTritonContext_AsTritonContext(self)->isSat(PyAstNode_AsAstNode(node)) == true)
2215 Py_RETURN_TRUE;
2216 Py_RETURN_FALSE;
2217 }
2218 catch (const triton::exceptions::PyCallbacks&) {
2219 return nullptr;
2220 }
2221 catch (const triton::exceptions::Exception& e) {
2222 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2223 }
2224 }
2225
2226
2227 static PyObject* TritonContext_isSymbolicExpressionExists(PyObject* self, PyObject* symExprId) {
2228 if (!PyInt_Check(symExprId) && !PyLong_Check(symExprId))
2229 return PyErr_Format(PyExc_TypeError, "TritonContext::isSymbolicExpressionExists(): Expects an integer as argument.");
2230
2231 try {
2232 if (PyTritonContext_AsTritonContext(self)->isSymbolicExpressionExists(PyLong_AsUsize(symExprId)) == true)
2233 Py_RETURN_TRUE;
2234 Py_RETURN_FALSE;
2235 }
2236 catch (const triton::exceptions::PyCallbacks&) {
2237 return nullptr;
2238 }
2239 catch (const triton::exceptions::Exception& e) {
2240 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2241 }
2242 }
2243
2244
2245 static PyObject* TritonContext_isModeEnabled(PyObject* self, PyObject* mode) {
2246 if (!PyInt_Check(mode) && !PyLong_Check(mode))
2247 return PyErr_Format(PyExc_TypeError, "TritonContext::isModeEnabled(): Expects a MODE as argument.");
2248
2249 try {
2250 if (PyTritonContext_AsTritonContext(self)->isModeEnabled(static_cast<triton::modes::mode_e>(PyLong_AsUint32(mode))) == true)
2251 Py_RETURN_TRUE;
2252 Py_RETURN_FALSE;
2253 }
2254 catch (const triton::exceptions::PyCallbacks&) {
2255 return nullptr;
2256 }
2257 catch (const triton::exceptions::Exception& e) {
2258 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2259 }
2260 }
2261
2262
2263 static PyObject* TritonContext_isThumb(PyObject* self, PyObject* noarg) {
2264 try {
2265 if (PyTritonContext_AsTritonContext(self)->isThumb() == true)
2266 Py_RETURN_TRUE;
2267 Py_RETURN_FALSE;
2268 }
2269 catch (const triton::exceptions::PyCallbacks&) {
2270 return nullptr;
2271 }
2272 catch (const triton::exceptions::Exception& e) {
2273 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2274 }
2275 }
2276
2277
2278 static PyObject* TritonContext_liftToDot(PyObject* self, PyObject* node) {
2279 if (!PyAstNode_Check(node) && !PySymbolicExpression_Check(node))
2280 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToDot(): Expects an AstNode or a SymbolicExpression as first argument.");
2281
2282 try {
2283 std::ostringstream stream;
2284
2285 if (PyAstNode_Check(node)) {
2286 PyTritonContext_AsTritonContext(self)->liftToDot(stream, PyAstNode_AsAstNode(node));
2287 }
2288 else {
2289 PyTritonContext_AsTritonContext(self)->liftToDot(stream, PySymbolicExpression_AsSymbolicExpression(node));
2290 }
2291
2292 return xPyString_FromString(stream.str().c_str());
2293 }
2294 catch (const triton::exceptions::PyCallbacks&) {
2295 return nullptr;
2296 }
2297 catch (const triton::exceptions::Exception& e) {
2298 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2299 }
2300
2301 Py_INCREF(Py_None);
2302 return Py_None;
2303 }
2304
2305
2306 static PyObject* TritonContext_liftToLLVM(PyObject* self, PyObject* args, PyObject* kwargs) {
2307 PyObject* node = nullptr;
2308 PyObject* fname = nullptr;
2309 PyObject* optimize = nullptr;
2310
2311 static char* keywords[] = {
2312 (char*)"node",
2313 (char*)"fname",
2314 (char*)"optimize",
2315 nullptr
2316 };
2317
2318 /* Extract keywords */
2319 if (PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO", keywords, &node, &fname, &optimize) == false) {
2320 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToLLVM(): Invalid number of arguments");
2321 }
2322
2323 if (node == nullptr || (!PySymbolicExpression_Check(node) && !PyAstNode_Check(node)))
2324 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToLLVM(): Expects a SymbolicExpression or a AstNode as node argument.");
2325
2326 if (fname != nullptr && !PyStr_Check(fname))
2327 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToLLVM(): Expects a string as fname argument.");
2328
2329 if (optimize != nullptr && !PyBool_Check(optimize))
2330 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToLLVM(): Expects a boolean as optimize argument.");
2331
2332 if (fname == nullptr)
2333 fname = PyStr_FromString("__triton");
2334
2335 if (optimize == nullptr)
2336 optimize = PyLong_FromUint32(false);
2337
2338 try {
2339 std::ostringstream stream;
2340 if (PySymbolicExpression_Check(node)) {
2341 PyTritonContext_AsTritonContext(self)->liftToLLVM(stream, PySymbolicExpression_AsSymbolicExpression(node), PyStr_AsString(fname), PyLong_AsBool(optimize));
2342 }
2343 else {
2344 PyTritonContext_AsTritonContext(self)->liftToLLVM(stream, PyAstNode_AsAstNode(node), PyStr_AsString(fname), PyLong_AsBool(optimize));
2345 }
2346 return xPyString_FromString(stream.str().c_str());
2347 }
2348 catch (const triton::exceptions::PyCallbacks&) {
2349 return nullptr;
2350 }
2351 catch (const triton::exceptions::Exception& e) {
2352 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2353 }
2354
2355 Py_INCREF(Py_None);
2356 return Py_None;
2357 }
2358
2359
2360 static PyObject* TritonContext_liftToPython(PyObject* self, PyObject* args, PyObject* kwargs) {
2361 PyObject* expr = nullptr;
2362 PyObject* icomment = nullptr;
2363
2364 static char* keywords[] = {
2365 (char*)"expr",
2366 (char*)"icomment",
2367 nullptr
2368 };
2369
2370 /* Extract keywords */
2371 if (PyArg_ParseTupleAndKeywords(args, kwargs, "|OO", keywords, &expr, &icomment) == false) {
2372 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToPython(): Invalid number of arguments");
2373 }
2374
2375 if (expr == nullptr || !PySymbolicExpression_Check(expr))
2376 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToPython(): Expects a SymbolicExpression as expr argument.");
2377
2378 if (icomment != nullptr && !PyBool_Check(icomment))
2379 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToPython(): Expects a boolean as icomment argument.");
2380
2381 if (icomment == nullptr)
2382 icomment = PyLong_FromUint32(false);
2383
2384 try {
2385 std::ostringstream stream;
2386 PyTritonContext_AsTritonContext(self)->liftToPython(stream, PySymbolicExpression_AsSymbolicExpression(expr), PyLong_AsBool(icomment));
2387 return xPyString_FromString(stream.str().c_str());
2388 }
2389 catch (const triton::exceptions::PyCallbacks&) {
2390 return nullptr;
2391 }
2392 catch (const triton::exceptions::Exception& e) {
2393 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2394 }
2395
2396 Py_INCREF(Py_None);
2397 return Py_None;
2398 }
2399
2400
2401 static PyObject* TritonContext_liftToSMT(PyObject* self, PyObject* args, PyObject* kwargs) {
2402 PyObject* expr = nullptr;
2403 PyObject* assert = nullptr;
2404 PyObject* icomment = nullptr;
2405
2406 static char* keywords[] = {
2407 (char*)"expr",
2408 (char*)"assert_",
2409 (char*)"icomment",
2410 nullptr
2411 };
2412
2413 /* Extract keywords */
2414 if (PyArg_ParseTupleAndKeywords(args, kwargs, "|OO", keywords, &expr, &assert, &icomment) == false) {
2415 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToSMT(): Invalid number of arguments");
2416 }
2417
2418 if (expr == nullptr || !PySymbolicExpression_Check(expr))
2419 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToSMT(): Expects a SymbolicExpression as expr argument.");
2420
2421 if (assert != nullptr && !PyBool_Check(assert))
2422 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToSMT(): Expects a boolean as assert_ argument.");
2423
2424 if (assert == nullptr)
2425 assert = PyLong_FromUint32(false);
2426
2427 if (icomment != nullptr && !PyBool_Check(icomment))
2428 return PyErr_Format(PyExc_TypeError, "TritonContext::liftToSMT(): Expects a boolean as icomment argument.");
2429
2430 if (icomment == nullptr)
2431 icomment = PyLong_FromUint32(false);
2432
2433 try {
2434 std::ostringstream stream;
2435 PyTritonContext_AsTritonContext(self)->liftToSMT(stream, PySymbolicExpression_AsSymbolicExpression(expr), PyLong_AsBool(assert), PyLong_AsBool(icomment));
2436 return xPyString_FromString(stream.str().c_str());
2437 }
2438 catch (const triton::exceptions::PyCallbacks&) {
2439 return nullptr;
2440 }
2441 catch (const triton::exceptions::Exception& e) {
2442 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2443 }
2444
2445 Py_INCREF(Py_None);
2446 return Py_None;
2447 }
2448
2449
2450 static PyObject* TritonContext_newSymbolicExpression(PyObject* self, PyObject* args) {
2451 PyObject* node = nullptr;
2452 PyObject* comment = nullptr;
2453 std::string ccomment = "";
2454
2455 /* Extract arguments */
2456 if (PyArg_ParseTuple(args, "|OO", &node, &comment) == false) {
2457 return PyErr_Format(PyExc_TypeError, "TritonContext::newSymbolicExpression(): Invalid number of arguments");
2458 }
2459
2460 if (node == nullptr || (!PyAstNode_Check(node)))
2461 return PyErr_Format(PyExc_TypeError, "TritonContext::newSymbolicExpression(): Expects a AstNode as first argument.");
2462
2463 if (comment != nullptr && !PyStr_Check(comment))
2464 return PyErr_Format(PyExc_TypeError, "TritonContext::newSymbolicExpression(): Expects a sting as second argument.");
2465
2466 if (comment != nullptr)
2467 ccomment = PyStr_AsString(comment);
2468
2469 try {
2470 return PySymbolicExpression(PyTritonContext_AsTritonContext(self)->newSymbolicExpression(PyAstNode_AsAstNode(node), ccomment));
2471 }
2472 catch (const triton::exceptions::PyCallbacks&) {
2473 return nullptr;
2474 }
2475 catch (const triton::exceptions::Exception& e) {
2476 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2477 }
2478 }
2479
2480
2481 static PyObject* TritonContext_newSymbolicVariable(PyObject* self, PyObject* args) {
2482 PyObject* size = nullptr;
2483 PyObject* alias = nullptr;
2484 std::string calias = "";
2485
2486 /* Extract arguments */
2487 if (PyArg_ParseTuple(args, "|OO", &size, &alias) == false) {
2488 return PyErr_Format(PyExc_TypeError, "TritonContext::newSymbolicVariable(): Invalid number of arguments");
2489 }
2490
2491 if (size == nullptr || (!PyLong_Check(size) && !PyInt_Check(size)))
2492 return PyErr_Format(PyExc_TypeError, "TritonContext::newSymbolicVariable(): Expects an integer as first argument.");
2493
2494 if (alias != nullptr && !PyStr_Check(alias))
2495 return PyErr_Format(PyExc_TypeError, "TritonContext::newSymbolicVariable(): Expects a sting as second argument.");
2496
2497 if (alias != nullptr)
2498 calias = PyStr_AsString(alias);
2499
2500 try {
2501 return PySymbolicVariable(PyTritonContext_AsTritonContext(self)->newSymbolicVariable(PyLong_AsUint32(size), calias));
2502 }
2503 catch (const triton::exceptions::PyCallbacks&) {
2504 return nullptr;
2505 }
2506 catch (const triton::exceptions::Exception& e) {
2507 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2508 }
2509 }
2510
2511
2512 static PyObject* TritonContext_popPathConstraint(PyObject* self, PyObject* noarg) {
2513 try {
2514 PyTritonContext_AsTritonContext(self)->popPathConstraint();
2515 }
2516 catch (const triton::exceptions::PyCallbacks&) {
2517 return nullptr;
2518 }
2519 catch (const triton::exceptions::Exception& e) {
2520 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2521 }
2522 Py_INCREF(Py_None);
2523 return Py_None;
2524 }
2525
2526
2527 static PyObject* TritonContext_processing(PyObject* self, PyObject* args) {
2528 PyObject* obj = nullptr;
2529 PyObject* addr = nullptr;
2530
2531 /* Extract arguments */
2532 if (PyArg_ParseTuple(args, "|OO", &obj, &addr) == false) {
2533 return PyErr_Format(PyExc_TypeError, "TritonContext::processing(): Invalid number of arguments");
2534 }
2535
2536 try {
2537 if (PyInstruction_Check(obj)) {
2538 return PyLong_FromUint32(PyTritonContext_AsTritonContext(self)->processing(*PyInstruction_AsInstruction(obj)));
2539 }
2540 else if (PyBasicBlock_Check(obj)) {
2541 triton::uint64 base = 0;
2542 if (addr != nullptr && (PyLong_Check(addr) || PyInt_Check(addr))) {
2543 base = PyLong_AsUint64(addr);
2544 }
2545 return PyLong_FromUint32(PyTritonContext_AsTritonContext(self)->processing(*PyBasicBlock_AsBasicBlock(obj), base));
2546 }
2547 return PyErr_Format(PyExc_TypeError, "TritonContext::processing(): Expects an Instruction or a BasicBlock as argument.");
2548 }
2549 catch (const triton::exceptions::PyCallbacks&) {
2550 return nullptr;
2551 }
2552 catch (const triton::exceptions::Exception& e) {
2553 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2554 }
2555 }
2556
2557
2558 static PyObject* TritonContext_pushPathConstraint(PyObject* self, PyObject* args, PyObject* kwargs) {
2559 PyObject* node = nullptr;
2560 PyObject* comment = nullptr;
2561 std::string ccomment = "";
2562
2563 static char* keywords[] = {
2564 (char*)"node",
2565 (char*)"comment",
2566 nullptr
2567 };
2568
2569 /* Extract Keywords */
2570 if (PyArg_ParseTupleAndKeywords(args, kwargs, "|OO", keywords, &node, &comment) == false) {
2571 return PyErr_Format(PyExc_TypeError, "TritonContext::pushPathConstraint(): Invalid keyword argument.");
2572 }
2573
2574 if (node == nullptr || (!PyAstNode_Check(node)))
2575 return PyErr_Format(PyExc_TypeError, "TritonContext::pushPathConstraint(): Expects an AstNode as first argument.");
2576
2577 if (comment != nullptr && !PyStr_Check(comment))
2578 return PyErr_Format(PyExc_TypeError, "TritonContext::pushPathConstraint(): Expects a string as second argument.");
2579
2580 if (comment != nullptr)
2581 ccomment = PyStr_AsString(comment);
2582
2583 try {
2584 PyTritonContext_AsTritonContext(self)->pushPathConstraint(PyAstNode_AsAstNode(node), ccomment);
2585 }
2586 catch (const triton::exceptions::PyCallbacks&) {
2587 return nullptr;
2588 }
2589 catch (const triton::exceptions::Exception& e) {
2590 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2591 }
2592
2593 Py_INCREF(Py_None);
2594 return Py_None;
2595 }
2596
2597
2598 static PyObject* TritonContext_removeCallback(PyObject* self, PyObject* args) {
2599 PyObject* cb = nullptr;
2600 PyObject* cb_self = nullptr;
2601 PyObject* function = nullptr;
2602 PyObject* mode = nullptr;
2603
2604 /* Extract arguments */
2605 if (PyArg_ParseTuple(args, "|OO", &mode, &function) == false) {
2606 return PyErr_Format(PyExc_TypeError, "TritonContext::removeCallback(): Invalid number of arguments");
2607 }
2608
2609 if (mode == nullptr || (!PyLong_Check(mode) && !PyInt_Check(mode)))
2610 return PyErr_Format(PyExc_TypeError, "TritonContext::removeCallback(): Expects a CALLBACK as first argument.");
2611
2612 if (function == nullptr || !PyCallable_Check(function))
2613 return PyErr_Format(PyExc_TypeError, "TritonContext::removeCallback(): Expects a function as second argument.");
2614
2615 /* Get the callback (class or static) */
2616 if (PyMethod_Check(function)) {
2617 cb_self = PyMethod_GET_SELF(function);
2618 cb = PyMethod_GET_FUNCTION(function);
2619 }
2620 else {
2621 cb = function;
2622 }
2623
2624 try {
2625 switch (static_cast<triton::callbacks::callback_e>(PyLong_AsUint32(mode))) {
2626 case callbacks::GET_CONCRETE_MEMORY_VALUE:
2627 PyTritonContext_AsTritonContext(self)->removeCallback(callbacks::GET_CONCRETE_MEMORY_VALUE, callbacks::getConcreteMemoryValueCallback(nullptr, cb));
2628 break;
2629 case callbacks::GET_CONCRETE_REGISTER_VALUE:
2630 PyTritonContext_AsTritonContext(self)->removeCallback(callbacks::GET_CONCRETE_REGISTER_VALUE, callbacks::getConcreteRegisterValueCallback(nullptr, cb));
2631 break;
2632 case callbacks::SET_CONCRETE_MEMORY_VALUE:
2633 PyTritonContext_AsTritonContext(self)->removeCallback(callbacks::SET_CONCRETE_MEMORY_VALUE, callbacks::setConcreteMemoryValueCallback(nullptr, cb));
2634 break;
2635 case callbacks::SET_CONCRETE_REGISTER_VALUE:
2636 PyTritonContext_AsTritonContext(self)->removeCallback(callbacks::SET_CONCRETE_REGISTER_VALUE, callbacks::setConcreteRegisterValueCallback(nullptr, cb));
2637 break;
2638 case callbacks::SYMBOLIC_SIMPLIFICATION:
2639 PyTritonContext_AsTritonContext(self)->removeCallback(callbacks::SYMBOLIC_SIMPLIFICATION, callbacks::symbolicSimplificationCallback(nullptr, cb));
2640 break;
2641 default:
2642 return PyErr_Format(PyExc_TypeError, "TritonContext::removeCallback(): Invalid kind of callback.");
2643 }
2644 }
2645 catch (const triton::exceptions::PyCallbacks&) {
2646 return nullptr;
2647 }
2648 catch (const triton::exceptions::Exception& e) {
2649 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2650 }
2651
2652 Py_DECREF(cb);
2653 if (cb_self != nullptr) {
2654 Py_DECREF(cb_self);
2655 }
2656
2657 Py_INCREF(Py_None);
2658 return Py_None;
2659 }
2660
2661
2662 static PyObject* TritonContext_reset(PyObject* self, PyObject* noarg) {
2663 try {
2664 PyTritonContext_AsTritonContext(self)->reset();
2665 }
2666 catch (const triton::exceptions::PyCallbacks&) {
2667 return nullptr;
2668 }
2669 catch (const triton::exceptions::Exception& e) {
2670 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2671 }
2672
2673 Py_INCREF(Py_None);
2674 return Py_None;
2675 }
2676
2677
2678 static PyObject* TritonContext_setArchitecture(PyObject* self, PyObject* arg) {
2679 if (!PyLong_Check(arg) && !PyInt_Check(arg))
2680 return PyErr_Format(PyExc_TypeError, "TritonContext::setArchitecture(): Expects an ARCH as argument.");
2681
2682 try {
2683 /* Set the architecture */
2684 PyTritonContext_AsTritonContext(self)->setArchitecture(static_cast<triton::arch::architecture_e>(PyLong_AsUint32(arg)));
2685 TritonContext_fillRegistersAttribute(self);
2686 }
2687 catch (const triton::exceptions::PyCallbacks&) {
2688 return nullptr;
2689 }
2690 catch (const triton::exceptions::Exception& e) {
2691 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2692 }
2693
2694 Py_INCREF(Py_None);
2695 return Py_None;
2696 }
2697
2698
2699 static PyObject* TritonContext_setAstRepresentationMode(PyObject* self, PyObject* arg) {
2700 if (!PyLong_Check(arg) && !PyInt_Check(arg))
2701 return PyErr_Format(PyExc_TypeError, "TritonContext::setAstRepresentationMode(): Expects an AST_REPRESENTATION as argument.");
2702
2703 try {
2704 PyTritonContext_AsTritonContext(self)->setAstRepresentationMode(static_cast<triton::ast::representations::mode_e>(PyLong_AsUint32(arg)));
2705 }
2706 catch (const triton::exceptions::PyCallbacks&) {
2707 return nullptr;
2708 }
2709 catch (const triton::exceptions::Exception& e) {
2710 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2711 }
2712
2713 Py_INCREF(Py_None);
2714 return Py_None;
2715 }
2716
2717
2718 static PyObject* TritonContext_setConcreteMemoryAreaValue(PyObject* self, PyObject* args, PyObject* kwargs) {
2719 std::vector<triton::uint8> vv;
2720 PyObject* baseAddr = nullptr;
2721 PyObject* values = nullptr;
2722 PyObject* execCallbacks = nullptr;
2723
2724 static char* keywords[] = {
2725 (char*)"addr",
2726 (char*)"values",
2727 (char*)"callbacks",
2728 nullptr
2729 };
2730
2731 /* Extract keywords */
2732 if (PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O", keywords, &baseAddr, &values, &execCallbacks) == false) {
2733 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryAreaValue(): Invalid keyword argument");
2734 }
2735
2736 if (baseAddr == nullptr || (!PyLong_Check(baseAddr) && !PyInt_Check(baseAddr))) {
2737 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryAreaValue(): Expects an integer as baseAddr keyword.");
2738 }
2739
2740 if (values == nullptr || (!PyList_Check(values) && !PyBytes_Check(values) && !PyByteArray_Check(values))) {
2741 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryAreaValue(): Expects a list or bytes as values keyword.");
2742 }
2743
2744 if (execCallbacks != nullptr && !PyBool_Check(execCallbacks)) {
2745 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryAreaValue(): Expects a boolean as execCallbacks keyword.");
2746 }
2747
2748 if (execCallbacks == nullptr) {
2749 execCallbacks = PyLong_FromUint32(true);
2750 }
2751
2752 // Python object: List
2753 if (PyList_Check(values)) {
2754 for (Py_ssize_t i = 0; i < PyList_Size(values); i++) {
2755 PyObject* item = PyList_GetItem(values, i);
2756
2757 if ((!PyLong_Check(item) && !PyInt_Check(item)) || PyLong_AsUint32(item) > 0xff)
2758 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryAreaValue(): Each item of the list must be a 8-bits integer.");
2759
2760 vv.push_back(static_cast<triton::uint8>(PyLong_AsUint32(item) & 0xff));
2761 }
2762
2763 try {
2764 PyTritonContext_AsTritonContext(self)->setConcreteMemoryAreaValue(PyLong_AsUint64(baseAddr), vv, PyLong_AsBool(execCallbacks));
2765 }
2766 catch (const triton::exceptions::PyCallbacks&) {
2767 return nullptr;
2768 }
2769 catch (const triton::exceptions::Exception& e) {
2770 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2771 }
2772 }
2773
2774 // Python object: Bytes
2775 else if (PyBytes_Check(values)) {
2776 triton::uint8* area = reinterpret_cast<triton::uint8*>(PyBytes_AsString(values));
2777 triton::usize size = static_cast<triton::usize>(PyBytes_Size(values));
2778
2779 try {
2780 PyTritonContext_AsTritonContext(self)->setConcreteMemoryAreaValue(PyLong_AsUint64(baseAddr), area, size, PyLong_AsBool(execCallbacks));
2781 }
2782 catch (const triton::exceptions::PyCallbacks&) {
2783 return nullptr;
2784 }
2785 catch (const triton::exceptions::Exception& e) {
2786 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2787 }
2788 }
2789
2790 // Python object: ByteArray
2791 else if (PyByteArray_Check(values)) {
2792 triton::uint8* area = reinterpret_cast<triton::uint8*>(PyByteArray_AsString(values));
2793 triton::usize size = static_cast<triton::usize>(PyByteArray_Size(values));
2794
2795 try {
2796 PyTritonContext_AsTritonContext(self)->setConcreteMemoryAreaValue(PyLong_AsUint64(baseAddr), area, size, PyLong_AsBool(execCallbacks));
2797 }
2798 catch (const triton::exceptions::PyCallbacks&) {
2799 return nullptr;
2800 }
2801 catch (const triton::exceptions::Exception& e) {
2802 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2803 }
2804 }
2805
2806 // Invalid Python object
2807 else
2808 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryAreaValue(): Something wrong.");
2809
2810 Py_INCREF(Py_None);
2811 return Py_None;
2812 }
2813
2814
2815 static PyObject* TritonContext_setConcreteMemoryValue(PyObject* self, PyObject* args, PyObject* kwargs) {
2816 PyObject* mem = nullptr;
2817 PyObject* value = nullptr;
2818 PyObject* execCallbacks = nullptr;
2819
2820 static char* keywords[] = {
2821 (char*)"mem",
2822 (char*)"value",
2823 (char*)"callbacks",
2824 nullptr
2825 };
2826
2827 /* Extract keywords */
2828 if (PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O", keywords, &mem, &value, &execCallbacks) == false) {
2829 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryValue(): Invalid keyword argument");
2830 }
2831
2832 if (mem == nullptr || (!PyLong_Check(mem) && !PyInt_Check(mem) && !PyMemoryAccess_Check(mem))) {
2833 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryValue(): Expects a MemoryAccess or an integer as mem keyword.");
2834 }
2835
2836 if (value == nullptr || (!PyLong_Check(value) && !PyInt_Check(value))) {
2837 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryValue(): Expects an integer as value keyword.");
2838 }
2839
2840 if (execCallbacks != nullptr && !PyBool_Check(execCallbacks)) {
2841 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryAreaValue(): Expects a boolean as execCallbacks keyword.");
2842 }
2843
2844 if (execCallbacks == nullptr) {
2845 execCallbacks = PyLong_FromUint32(true);
2846 }
2847
2848 /* setConcreteMemoryValue(integer, integer) */
2849 if (PyLong_Check(mem) || PyInt_Check(mem)) {
2850 triton::uint64 addr = PyLong_AsUint64(mem);
2851 triton::uint32 cvalue = PyLong_AsUint32(value);
2852
2853 if (cvalue > 0xff)
2854 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryValue(): Value must be on 8 bits.");
2855
2856 try {
2857 PyTritonContext_AsTritonContext(self)->setConcreteMemoryValue(addr, static_cast<triton::uint8>(cvalue & 0xff), PyLong_AsBool(execCallbacks));
2858 }
2859 catch (const triton::exceptions::PyCallbacks&) {
2860 return nullptr;
2861 }
2862 catch (const triton::exceptions::Exception& e) {
2863 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2864 }
2865
2866 }
2867
2868 /* setConcreteMemoryValue(MemoryAccess) */
2869 else if (PyMemoryAccess_Check(mem)) {
2870 try {
2871 triton::uint512 cvalue = PyLong_AsUint512(value);
2872 PyTritonContext_AsTritonContext(self)->setConcreteMemoryValue(*PyMemoryAccess_AsMemoryAccess(mem), cvalue, PyLong_AsBool(execCallbacks));
2873 }
2874 catch (const triton::exceptions::PyCallbacks&) {
2875 return nullptr;
2876 }
2877 catch (const triton::exceptions::Exception& e) {
2878 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2879 }
2880 }
2881
2882 /* Invalid */
2883 else
2884 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryValue(): something wrong.");
2885
2886 Py_INCREF(Py_None);
2887 return Py_None;
2888 }
2889
2890
2891 static PyObject* TritonContext_setConcreteRegisterValue(PyObject* self, PyObject* args, PyObject* kwargs) {
2892 PyObject* reg = nullptr;
2893 PyObject* value = nullptr;
2894 PyObject* execCallbacks = nullptr;
2895
2896 static char* keywords[] = {
2897 (char*)"reg",
2898 (char*)"value",
2899 (char*)"callbacks",
2900 nullptr
2901 };
2902
2903 /* Extract keywords */
2904 if (PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O", keywords, &reg, &value, &execCallbacks) == false) {
2905 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteRegisterValue(): Invalid keyword argument");
2906 }
2907
2908 if (reg == nullptr || !PyRegister_Check(reg)) {
2909 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteRegisterValue(): Expects a Register as reg keyword.");
2910 }
2911
2912 if (value == nullptr || (!PyLong_Check(value) && !PyInt_Check(value))) {
2913 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteRegisterValue(): Expects an integer as value keyword.");
2914 }
2915
2916 if (execCallbacks != nullptr && !PyBool_Check(execCallbacks)) {
2917 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteMemoryAreaValue(): Expects a boolean as execCallbacks keyword.");
2918 }
2919
2920 if (execCallbacks == nullptr) {
2921 execCallbacks = PyLong_FromUint32(true);
2922 }
2923
2924 try {
2925 triton::uint512 cvalue = PyLong_AsUint512(value);
2926 PyTritonContext_AsTritonContext(self)->setConcreteRegisterValue(*PyRegister_AsRegister(reg), cvalue, PyLong_AsBool(execCallbacks));
2927 }
2928 catch (const triton::exceptions::PyCallbacks&) {
2929 return nullptr;
2930 }
2931 catch (const triton::exceptions::Exception& e) {
2932 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2933 }
2934
2935 Py_INCREF(Py_None);
2936 return Py_None;
2937 }
2938
2939
2940 static PyObject* TritonContext_setConcreteVariableValue(PyObject* self, PyObject* args) {
2941 PyObject* symVar = nullptr;
2942 PyObject* value = nullptr;
2943
2944 /* Extract arguments */
2945 if (PyArg_ParseTuple(args, "|OO", &symVar, &value) == false) {
2946 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteVariableValue(): Invalid number of arguments");
2947 }
2948
2949 if (symVar == nullptr || !PySymbolicVariable_Check(symVar))
2950 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteVariableValue(): Bad argument type.");
2951
2952 if (value == nullptr)
2953 return PyErr_Format(PyExc_TypeError, "TritonContext::setConcreteVariableValue(): Expects a second argument as integer value.");
2954
2955 try {
2956 PyTritonContext_AsTritonContext(self)->setConcreteVariableValue(PySymbolicVariable_AsSymbolicVariable(symVar), PyLong_AsUint512(value));
2957 }
2958 catch (const triton::exceptions::PyCallbacks&) {
2959 return nullptr;
2960 }
2961 catch (const triton::exceptions::Exception& e) {
2962 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2963 }
2964
2965 Py_INCREF(Py_None);
2966 return Py_None;
2967 }
2968
2969
2970 static PyObject* TritonContext_setMode(PyObject* self, PyObject* args) {
2971 PyObject* mode = nullptr;
2972 PyObject* flag = nullptr;
2973
2974 /* Extract arguments */
2975 if (PyArg_ParseTuple(args, "|OO", &mode, &flag) == false) {
2976 return PyErr_Format(PyExc_TypeError, "TritonContext::setMode(): Invalid number of arguments");
2977 }
2978
2979 if (mode == nullptr || (!PyLong_Check(mode) && !PyInt_Check(mode)))
2980 return PyErr_Format(PyExc_TypeError, "TritonContext::setMode(): Expects a MODE as argument.");
2981
2982 if (flag == nullptr || !PyBool_Check(flag))
2983 return PyErr_Format(PyExc_TypeError, "TritonContext::setMode(): Expects an boolean flag as second argument.");
2984
2985 try {
2986 PyTritonContext_AsTritonContext(self)->setMode(static_cast<triton::modes::mode_e>(PyLong_AsUint32(mode)), PyLong_AsBool(flag));
2987 }
2988 catch (const triton::exceptions::PyCallbacks&) {
2989 return nullptr;
2990 }
2991 catch (const triton::exceptions::Exception& e) {
2992 return PyErr_Format(PyExc_TypeError, "%s", e.what());
2993 }
2994
2995 Py_INCREF(Py_None);
2996 return Py_None;
2997 }
2998
2999
3000 static PyObject* TritonContext_setSolver(PyObject* self, PyObject* solver) {
3001 if (solver == nullptr || (!PyLong_Check(solver) && !PyInt_Check(solver)))
3002 return PyErr_Format(PyExc_TypeError, "TritonContext::setSolver(): Expects a SOLVER as argument.");
3003
3004 try {
3005 PyTritonContext_AsTritonContext(self)->setSolver(static_cast<triton::engines::solver::solver_e>(PyLong_AsUint32(solver)));
3006 }
3007 catch (const triton::exceptions::Exception& e) {
3008 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3009 }
3010
3011 Py_INCREF(Py_None);
3012 return Py_None;
3013 }
3014
3015
3016 static PyObject* TritonContext_setSolverMemoryLimit(PyObject* self, PyObject* megabytes) {
3017 if (megabytes == nullptr || (!PyLong_Check(megabytes) && !PyInt_Check(megabytes)))
3018 return PyErr_Format(PyExc_TypeError, "TritonContext::setSolverMemoryLimit(): Expects an integer as argument.");
3019
3020 try {
3021 PyTritonContext_AsTritonContext(self)->setSolverMemoryLimit(PyLong_AsUint32(megabytes));
3022 }
3023 catch (const triton::exceptions::Exception& e) {
3024 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3025 }
3026
3027 Py_INCREF(Py_None);
3028 return Py_None;
3029 }
3030
3031
3032 static PyObject* TritonContext_setSolverTimeout(PyObject* self, PyObject* ms) {
3033 if (ms == nullptr || (!PyLong_Check(ms) && !PyInt_Check(ms)))
3034 return PyErr_Format(PyExc_TypeError, "TritonContext::setSolverTimeout(): Expects an integer as argument.");
3035
3036 try {
3037 PyTritonContext_AsTritonContext(self)->setSolverTimeout(PyLong_AsUint32(ms));
3038 }
3039 catch (const triton::exceptions::Exception& e) {
3040 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3041 }
3042
3043 Py_INCREF(Py_None);
3044 return Py_None;
3045 }
3046
3047
3048 static PyObject* TritonContext_setTaintMemory(PyObject* self, PyObject* args) {
3049 PyObject* mem = nullptr;
3050 PyObject* flag = nullptr;
3051
3052 /* Extract arguments */
3053 if (PyArg_ParseTuple(args, "|OO", &mem, &flag) == false) {
3054 return PyErr_Format(PyExc_TypeError, "TritonContext::setTaintMemory(): Invalid number of arguments");
3055 }
3056
3057 if (mem == nullptr || !PyMemoryAccess_Check(mem))
3058 return PyErr_Format(PyExc_TypeError, "TritonContext::setTaintMemory(): Expects a MemoryAccess as first argument.");
3059
3060 if (flag == nullptr || !PyBool_Check(flag))
3061 return PyErr_Format(PyExc_TypeError, "TritonContext::setTaintMemory(): Expects a boolean as second argument.");
3062
3063 try {
3064 if (PyTritonContext_AsTritonContext(self)->setTaintMemory(*PyMemoryAccess_AsMemoryAccess(mem), PyLong_AsBool(flag)) == true)
3065 Py_RETURN_TRUE;
3066 Py_RETURN_FALSE;
3067 }
3068 catch (const triton::exceptions::PyCallbacks&) {
3069 return nullptr;
3070 }
3071 catch (const triton::exceptions::Exception& e) {
3072 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3073 }
3074 }
3075
3076
3077 static PyObject* TritonContext_setTaintRegister(PyObject* self, PyObject* args) {
3078 PyObject* reg = nullptr;
3079 PyObject* flag = nullptr;
3080
3081 /* Extract arguments */
3082 if (PyArg_ParseTuple(args, "|OO", &reg, &flag) == false) {
3083 return PyErr_Format(PyExc_TypeError, "TritonContext::setTaintRegister(): Invalid number of arguments");
3084 }
3085
3086 if (reg == nullptr || !PyRegister_Check(reg))
3087 return PyErr_Format(PyExc_TypeError, "TritonContext::setTaintRegister(): Expects a Register as first argument.");
3088
3089 if (flag == nullptr || !PyBool_Check(flag))
3090 return PyErr_Format(PyExc_TypeError, "TritonContext::setTaintRegister(): Expects a boolean as second argument.");
3091
3092 try {
3093 if (PyTritonContext_AsTritonContext(self)->setTaintRegister(*PyRegister_AsRegister(reg), PyLong_AsBool(flag)) == true)
3094 Py_RETURN_TRUE;
3095 Py_RETURN_FALSE;
3096 }
3097 catch (const triton::exceptions::PyCallbacks&) {
3098 return nullptr;
3099 }
3100 catch (const triton::exceptions::Exception& e) {
3101 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3102 }
3103 }
3104
3105
3106 static PyObject* TritonContext_setThumb(PyObject* self, PyObject* state) {
3107 if (state == nullptr || !PyBool_Check(state))
3108 return PyErr_Format(PyExc_TypeError, "TritonContext::setThumb(): Expects an boolean as argument.");
3109
3110 try {
3111 PyTritonContext_AsTritonContext(self)->setThumb(PyLong_AsBool(state));
3112 }
3113 catch (const triton::exceptions::Exception& e) {
3114 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3115 }
3116
3117 Py_INCREF(Py_None);
3118 return Py_None;
3119 }
3120
3121
3122 static PyObject* TritonContext_simplify(PyObject* self, PyObject* args, PyObject* kwargs) {
3123 PyObject* obj = nullptr;
3124 PyObject* solver = nullptr;
3125 PyObject* llvm = nullptr;
3126 PyObject* padding = nullptr;
3127
3128 static char* keywords[] = {
3129 (char*)"obj",
3130 (char*)"solver",
3131 (char*)"llvm",
3132 (char*)"padding",
3133 nullptr
3134 };
3135
3136 /* Extract keywords */
3137 if (PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO", keywords, &obj, &solver, &llvm, &padding) == false) {
3138 return PyErr_Format(PyExc_TypeError, "TritonContext::simplify(): Invalid number of arguments");
3139 }
3140
3141 if (obj == nullptr || (!PyAstNode_Check(obj) && !PyBasicBlock_Check(obj)))
3142 return PyErr_Format(PyExc_TypeError, "TritonContext::simplify(): Expects a AstNode or a BasicBlock as obj argument.");
3143
3144 if (solver != nullptr && !PyBool_Check(solver))
3145 return PyErr_Format(PyExc_TypeError, "TritonContext::simplify(): Expects a boolean as solver argument.");
3146
3147 if (llvm != nullptr && !PyBool_Check(llvm))
3148 return PyErr_Format(PyExc_TypeError, "TritonContext::simplify(): Expects a boolean as llvm argument.");
3149
3150 if (padding != nullptr && !PyBool_Check(padding))
3151 return PyErr_Format(PyExc_TypeError, "TritonContext::simplify(): Expects a boolean as padding argument.");
3152
3153 if (solver == nullptr)
3154 solver = PyLong_FromUint32(false);
3155
3156 if (llvm == nullptr)
3157 llvm = PyLong_FromUint32(false);
3158
3159 if (padding == nullptr)
3160 padding = PyLong_FromUint32(false);
3161
3162 try {
3163 if (PyAstNode_Check(obj))
3164 return PyAstNode(PyTritonContext_AsTritonContext(self)->simplify(PyAstNode_AsAstNode(obj), PyLong_AsBool(solver), PyLong_AsBool(llvm)));
3165
3166 else if (PyBasicBlock_Check(obj))
3167 return PyBasicBlock(PyTritonContext_AsTritonContext(self)->simplify(*PyBasicBlock_AsBasicBlock(obj), PyLong_AsBool(padding)));
3168
3169 else
3170 return PyErr_Format(PyExc_TypeError, "TritonContext::simplify(): Something wrong.");
3171 }
3172 catch (const triton::exceptions::PyCallbacks&) {
3173 return nullptr;
3174 }
3175 catch (const triton::exceptions::Exception& e) {
3176 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3177 }
3178 }
3179
3180
3181 static PyObject* TritonContext_sliceExpressions(PyObject* self, PyObject* expr) {
3182 PyObject* ret = nullptr;
3183
3184 if (!PySymbolicExpression_Check(expr))
3185 return PyErr_Format(PyExc_TypeError, "TritonContext::sliceExpressions(): Expects a SymbolicExpression as argument.");
3186
3187 try {
3188 auto exprs = PyTritonContext_AsTritonContext(self)->sliceExpressions(PySymbolicExpression_AsSymbolicExpression(expr));
3189
3190 ret = xPyDict_New();
3191 for (auto it = exprs.begin(); it != exprs.end(); it++)
3192 xPyDict_SetItem(ret, PyLong_FromUsize(it->first), PySymbolicExpression(it->second));
3193 }
3194 catch (const triton::exceptions::PyCallbacks&) {
3195 return nullptr;
3196 }
3197 catch (const triton::exceptions::Exception& e) {
3198 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3199 }
3200
3201 return ret;
3202 }
3203
3204
3205 static PyObject* TritonContext_symbolizeExpression(PyObject* self, PyObject* args) {
3206 PyObject* exprId = nullptr;
3207 PyObject* symVarSize = nullptr;
3208 PyObject* symVarAlias = nullptr;
3209 std::string calias = "";
3210
3211 /* Extract arguments */
3212 if (PyArg_ParseTuple(args, "|OOO", &exprId, &symVarSize, &symVarAlias) == false) {
3213 return PyErr_Format(PyExc_TypeError, "TritonContext::symbolizeExpression(): Invalid number of arguments");
3214 }
3215
3216 if (exprId == nullptr || (!PyLong_Check(exprId) && !PyInt_Check(exprId)))
3217 return PyErr_Format(PyExc_TypeError, "TritonContext::symbolizeExpression(): Expects an integer as first argument.");
3218
3219 if (symVarSize == nullptr || (!PyLong_Check(symVarSize) && !PyInt_Check(symVarSize)))
3220 return PyErr_Format(PyExc_TypeError, "TritonContext::symbolizeExpression(): Expects an integer as second argument.");
3221
3222 if (symVarAlias != nullptr && !PyStr_Check(symVarAlias))
3223 return PyErr_Format(PyExc_TypeError, "TritonContext::symbolizeExpression(): Expects a sting as third argument.");
3224
3225 if (symVarAlias != nullptr)
3226 calias = PyStr_AsString(symVarAlias);
3227
3228 try {
3229 return PySymbolicVariable(PyTritonContext_AsTritonContext(self)->symbolizeExpression(PyLong_AsUsize(exprId), PyLong_AsUint32(symVarSize), calias));
3230 }
3231 catch (const triton::exceptions::PyCallbacks&) {
3232 return nullptr;
3233 }
3234 catch (const triton::exceptions::Exception& e) {
3235 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3236 }
3237 }
3238
3239
3240 static PyObject* TritonContext_symbolizeMemory(PyObject* self, PyObject* args) {
3241 PyObject* mem = nullptr;
3242 PyObject* symVarAlias = nullptr;
3243 std::string calias = "";
3244
3245 /* Extract arguments */
3246 if (PyArg_ParseTuple(args, "|OO", &mem, &symVarAlias) == false) {
3247 return PyErr_Format(PyExc_TypeError, "TritonContext::symbolizeMemory(): Invalid number of arguments");
3248 }
3249
3250 if (mem == nullptr || (!PyMemoryAccess_Check(mem)))
3251 return PyErr_Format(PyExc_TypeError, "TritonContext::symbolizeMemory(): Expects a MemoryAccess as first argument.");
3252
3253 if (symVarAlias != nullptr && !PyStr_Check(symVarAlias))
3254 return PyErr_Format(PyExc_TypeError, "TritonContext::symbolizeMemory(): Expects a sting as second argument.");
3255
3256 if (symVarAlias != nullptr)
3257 calias = PyStr_AsString(symVarAlias);
3258
3259 try {
3260 return PySymbolicVariable(PyTritonContext_AsTritonContext(self)->symbolizeMemory(*PyMemoryAccess_AsMemoryAccess(mem), calias));
3261 }
3262 catch (const triton::exceptions::PyCallbacks&) {
3263 return nullptr;
3264 }
3265 catch (const triton::exceptions::Exception& e) {
3266 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3267 }
3268 }
3269
3270
3271 static PyObject* TritonContext_symbolizeRegister(PyObject* self, PyObject* args) {
3272 PyObject* reg = nullptr;
3273 PyObject* symVarAlias = nullptr;
3274 std::string calias = "";
3275
3276 /* Extract arguments */
3277 if (PyArg_ParseTuple(args, "|OO", &reg, &symVarAlias) == false) {
3278 return PyErr_Format(PyExc_TypeError, "TritonContext::symbolizeRegister(): Invalid number of arguments");
3279 }
3280
3281 if (reg == nullptr || (!PyRegister_Check(reg)))
3282 return PyErr_Format(PyExc_TypeError, "TritonContext::symbolizeRegister(): Expects a Register as first argument.");
3283
3284 if (symVarAlias != nullptr && !PyStr_Check(symVarAlias))
3285 return PyErr_Format(PyExc_TypeError, "TritonContext::symbolizeRegister(): Expects a sting as second argument.");
3286
3287 if (symVarAlias != nullptr)
3288 calias = PyStr_AsString(symVarAlias);
3289
3290 try {
3291 return PySymbolicVariable(PyTritonContext_AsTritonContext(self)->symbolizeRegister(*PyRegister_AsRegister(reg), calias));
3292 }
3293 catch (const triton::exceptions::PyCallbacks&) {
3294 return nullptr;
3295 }
3296 catch (const triton::exceptions::Exception& e) {
3297 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3298 }
3299 }
3300
3301
3302 static PyObject* TritonContext_synthesize(PyObject* self, PyObject* args, PyObject* kwargs) {
3303 PyObject* node = nullptr;
3304 PyObject* constant = nullptr;
3305 PyObject* subexpr = nullptr;
3306 PyObject* opaque = nullptr;
3307
3308 static char* keywords[] = {
3309 (char*)"node",
3310 (char*)"constant",
3311 (char*)"subexpr",
3312 (char*)"opaque",
3313 nullptr
3314 };
3315
3316 /* Extract keywords */
3317 if (PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO", keywords, &node, &constant, &subexpr, &opaque) == false) {
3318 return PyErr_Format(PyExc_TypeError, "TritonContext::synthesize(): Invalid number of arguments");
3319 }
3320
3321 if (node == nullptr || !PyAstNode_Check(node))
3322 return PyErr_Format(PyExc_TypeError, "TritonContext::synthesize(): Expects a AstNode as node argument.");
3323
3324 if (constant != nullptr && !PyBool_Check(constant))
3325 return PyErr_Format(PyExc_TypeError, "TritonContext::synthesize(): Expects a boolean as constant argument.");
3326
3327 if (subexpr != nullptr && !PyBool_Check(subexpr))
3328 return PyErr_Format(PyExc_TypeError, "TritonContext::synthesize(): Expects a boolean as subexpr argument.");
3329
3330 if (opaque != nullptr && !PyBool_Check(opaque))
3331 return PyErr_Format(PyExc_TypeError, "TritonContext::synthesize(): Expects a boolean as opaque argument.");
3332
3333 if (constant == nullptr)
3334 constant = PyLong_FromUint32(true);
3335
3336 if (subexpr == nullptr)
3337 subexpr = PyLong_FromUint32(true);
3338
3339 if (opaque == nullptr)
3340 opaque = PyLong_FromUint32(false);
3341
3342 try {
3343 auto result = PyTritonContext_AsTritonContext(self)->synthesize(PyAstNode_AsAstNode(node), PyLong_AsBool(constant), PyLong_AsBool(subexpr), PyLong_AsBool(opaque));
3344 if (result.successful()) {
3345 return PyAstNode(result.getOutput());
3346 }
3347 else {
3348 Py_INCREF(Py_None);
3349 return Py_None;
3350 }
3351 }
3352 catch (const triton::exceptions::PyCallbacks&) {
3353 return nullptr;
3354 }
3355 catch (const triton::exceptions::Exception& e) {
3356 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3357 }
3358 }
3359
3360
3361 static PyObject* TritonContext_taintAssignment(PyObject* self, PyObject* args) {
3362 PyObject* op1 = nullptr;
3363 PyObject* op2 = nullptr;
3364 bool ret = false;
3365
3366 /* Extract arguments */
3367 if (PyArg_ParseTuple(args, "OO", &op1, &op2) == false) {
3368 return PyErr_Format(PyExc_TypeError, "TritonContext::taintAssignment(): Invalid number of arguments");
3369 }
3370
3371 try {
3372 if (PyMemoryAccess_Check(op1) && PyImmediate_Check(op2))
3373 ret = PyTritonContext_AsTritonContext(self)->taintAssignment(*PyMemoryAccess_AsMemoryAccess(op1), *PyImmediate_AsImmediate(op2));
3374
3375 else if (PyMemoryAccess_Check(op1) && PyMemoryAccess_Check(op2))
3376 ret = PyTritonContext_AsTritonContext(self)->taintAssignment(*PyMemoryAccess_AsMemoryAccess(op1), *PyMemoryAccess_AsMemoryAccess(op2));
3377
3378 else if (PyMemoryAccess_Check(op1) && PyRegister_Check(op2))
3379 ret = PyTritonContext_AsTritonContext(self)->taintAssignment(*PyMemoryAccess_AsMemoryAccess(op1), *PyRegister_AsRegister(op2));
3380
3381 else if (PyRegister_Check(op1) && PyImmediate_Check(op2))
3382 ret = PyTritonContext_AsTritonContext(self)->taintAssignment(*PyRegister_AsRegister(op1), *PyImmediate_AsImmediate(op2));
3383
3384 else if (PyRegister_Check(op1) && PyMemoryAccess_Check(op2))
3385 ret = PyTritonContext_AsTritonContext(self)->taintAssignment(*PyRegister_AsRegister(op1), *PyMemoryAccess_AsMemoryAccess(op2));
3386
3387 else if (PyRegister_Check(op1) && PyRegister_Check(op2))
3388 ret = PyTritonContext_AsTritonContext(self)->taintAssignment(*PyRegister_AsRegister(op1), *PyRegister_AsRegister(op2));
3389
3390 else
3391 return PyErr_Format(PyExc_TypeError, "TritonContext::taintAssignment(): Invalid kind of parameter.");
3392
3393 if (ret == true) {
3394 Py_RETURN_TRUE;
3395 }
3396 Py_RETURN_FALSE;
3397 }
3398 catch (const triton::exceptions::PyCallbacks&) {
3399 return nullptr;
3400 }
3401 catch (const triton::exceptions::Exception& e) {
3402 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3403 }
3404 }
3405
3406
3407 static PyObject* TritonContext_taintMemory(PyObject* self, PyObject* mem) {
3408 try {
3409 if (PyMemoryAccess_Check(mem)) {
3410 if (PyTritonContext_AsTritonContext(self)->taintMemory(*PyMemoryAccess_AsMemoryAccess(mem)) == true)
3411 Py_RETURN_TRUE;
3412 }
3413
3414 else if (PyLong_Check(mem) || PyInt_Check(mem)) {
3415 if (PyTritonContext_AsTritonContext(self)->taintMemory(PyLong_AsUint64(mem)) == true)
3416 Py_RETURN_TRUE;
3417 }
3418
3419 else
3420 return PyErr_Format(PyExc_TypeError, "TritonContext::taintMemory(): Expects a MemoryAccess or an integer as argument.");
3421 }
3422 catch (const triton::exceptions::PyCallbacks&) {
3423 return nullptr;
3424 }
3425 catch (const triton::exceptions::Exception& e) {
3426 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3427 }
3428 Py_RETURN_FALSE;
3429 }
3430
3431
3432 static PyObject* TritonContext_taintRegister(PyObject* self, PyObject* reg) {
3433 if (!PyRegister_Check(reg))
3434 return PyErr_Format(PyExc_TypeError, "TritonContext::taintRegister(): Expects a Register as argument.");
3435
3436 try {
3437 if (PyTritonContext_AsTritonContext(self)->taintRegister(*PyRegister_AsRegister(reg)) == true)
3438 Py_RETURN_TRUE;
3439 Py_RETURN_FALSE;
3440 }
3441 catch (const triton::exceptions::PyCallbacks&) {
3442 return nullptr;
3443 }
3444 catch (const triton::exceptions::Exception& e) {
3445 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3446 }
3447 }
3448
3449
3450 static PyObject* TritonContext_taintUnion(PyObject* self, PyObject* args) {
3451 PyObject* op1 = nullptr;
3452 PyObject* op2 = nullptr;
3453 bool ret = false;
3454
3455 /* Extract arguments */
3456 if (PyArg_ParseTuple(args, "OO", &op1, &op2) == false) {
3457 return PyErr_Format(PyExc_TypeError, "TritonContext::taintUnion(): Invalid number of arguments");
3458 }
3459
3460 try {
3461 if (PyMemoryAccess_Check(op1) && PyImmediate_Check(op2))
3462 ret = PyTritonContext_AsTritonContext(self)->taintUnion(*PyMemoryAccess_AsMemoryAccess(op1), *PyImmediate_AsImmediate(op2));
3463
3464 else if (PyMemoryAccess_Check(op1) && PyMemoryAccess_Check(op2))
3465 ret = PyTritonContext_AsTritonContext(self)->taintUnion(*PyMemoryAccess_AsMemoryAccess(op1), *PyMemoryAccess_AsMemoryAccess(op2));
3466
3467 else if (PyMemoryAccess_Check(op1) && PyRegister_Check(op2))
3468 ret = PyTritonContext_AsTritonContext(self)->taintUnion(*PyMemoryAccess_AsMemoryAccess(op1), *PyRegister_AsRegister(op2));
3469
3470 else if (PyRegister_Check(op1) && PyImmediate_Check(op2))
3471 ret = PyTritonContext_AsTritonContext(self)->taintUnion(*PyRegister_AsRegister(op1), *PyImmediate_AsImmediate(op2));
3472
3473 else if (PyRegister_Check(op1) && PyMemoryAccess_Check(op2))
3474 ret = PyTritonContext_AsTritonContext(self)->taintUnion(*PyRegister_AsRegister(op1), *PyMemoryAccess_AsMemoryAccess(op2));
3475
3476 else if (PyRegister_Check(op1) && PyRegister_Check(op2))
3477 ret = PyTritonContext_AsTritonContext(self)->taintUnion(*PyRegister_AsRegister(op1), *PyRegister_AsRegister(op2));
3478
3479 else
3480 return PyErr_Format(PyExc_TypeError, "TritonContext::taintUnion(): Invalid kind of parameter.");
3481
3482 if (ret == true) {
3483 Py_RETURN_TRUE;
3484 }
3485 Py_RETURN_FALSE;
3486 }
3487 catch (const triton::exceptions::PyCallbacks&) {
3488 return nullptr;
3489 }
3490 catch (const triton::exceptions::Exception& e) {
3491 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3492 }
3493 }
3494
3495
3496 static PyObject* TritonContext_untaintMemory(PyObject* self, PyObject* mem) {
3497 try {
3498 if (PyMemoryAccess_Check(mem)) {
3499 if (PyTritonContext_AsTritonContext(self)->untaintMemory(*PyMemoryAccess_AsMemoryAccess(mem)) == true)
3500 Py_RETURN_TRUE;
3501 }
3502
3503 else if (PyLong_Check(mem) || PyInt_Check(mem)) {
3504 if (PyTritonContext_AsTritonContext(self)->untaintMemory(PyLong_AsUint64(mem)) == true)
3505 Py_RETURN_TRUE;
3506 }
3507
3508 else
3509 return PyErr_Format(PyExc_TypeError, "TritonContext::untaintMemory(): Expects a MemoryAccess or an integer as argument.");
3510 }
3511 catch (const triton::exceptions::PyCallbacks&) {
3512 return nullptr;
3513 }
3514 catch (const triton::exceptions::Exception& e) {
3515 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3516 }
3517 Py_RETURN_FALSE;
3518 }
3519
3520
3521 static PyObject* TritonContext_untaintRegister(PyObject* self, PyObject* reg) {
3522 if (!PyRegister_Check(reg))
3523 return PyErr_Format(PyExc_TypeError, "TritonContext::untaintRegister(): Expects a Register as argument.");
3524
3525 try {
3526 if (PyTritonContext_AsTritonContext(self)->untaintRegister(*PyRegister_AsRegister(reg)) == true)
3527 Py_RETURN_TRUE;
3528 Py_RETURN_FALSE;
3529 }
3530 catch (const triton::exceptions::PyCallbacks&) {
3531 return nullptr;
3532 }
3533 catch (const triton::exceptions::Exception& e) {
3534 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3535 }
3536 }
3537
3538
3539 static PyObject* TritonContext_getParentRegister(PyObject* self, PyObject* reg) {
3540 if (!PyRegister_Check(reg))
3541 return PyErr_Format(PyExc_TypeError, "TritonContext::getParentRegister(): Expects a Register as argument.");
3542
3543 try {
3544 return PyRegister(PyTritonContext_AsTritonContext(self)->getParentRegister(PyRegister_AsRegister(reg)->getId()));
3545 }
3546 catch (const triton::exceptions::PyCallbacks&) {
3547 return nullptr;
3548 }
3549 catch (const triton::exceptions::Exception& e) {
3550 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3551 }
3552 }
3553
3554
3555 static PyObject* TritonContext_getattro(PyObject* self, PyObject* name) {
3556 try {
3557 /* Access to the registers attribute */
3558 if (std::string(PyStr_AsString(name)) == "registers") {
3559
3560 /* Check if the architecture is defined */
3561 if (PyTritonContext_AsTritonContext(self)->getArchitecture() == triton::arch::ARCH_INVALID)
3562 return PyErr_Format(PyExc_TypeError, "__getattr__.registers: Architecture is not defined.");
3563
3564 /* Maybe null if TritonContext was created over the PyTritonContextRef function */
3565 if (((TritonContext_Object*)(self))->regAttr == nullptr)
3566 TritonContext_fillRegistersAttribute(self);
3567
3568 Py_INCREF(((TritonContext_Object*)(self))->regAttr);
3569 return ((TritonContext_Object*)(self))->regAttr;
3570 }
3571 }
3572 catch (const triton::exceptions::PyCallbacks&) {
3573 return nullptr;
3574 }
3575 catch (const triton::exceptions::Exception& e) {
3576 return PyErr_Format(PyExc_TypeError, "%s", e.what());
3577 }
3578
3579 return PyObject_GenericGetAttr((PyObject *)self, name);
3580 }
3581
3582
3584 PyMethodDef TritonContext_callbacks[] = {
3585 {"addCallback", (PyCFunction)TritonContext_addCallback, METH_VARARGS, ""},
3586 {"assignSymbolicExpressionToMemory", (PyCFunction)TritonContext_assignSymbolicExpressionToMemory, METH_VARARGS, ""},
3587 {"assignSymbolicExpressionToRegister", (PyCFunction)TritonContext_assignSymbolicExpressionToRegister, METH_VARARGS, ""},
3588 {"buildSemantics", (PyCFunction)TritonContext_buildSemantics, METH_O, ""},
3589 {"clearCallbacks", (PyCFunction)TritonContext_clearCallbacks, METH_NOARGS, ""},
3590 {"clearModes", (PyCFunction)TritonContext_clearModes, METH_NOARGS, ""},
3591 {"clearConcreteMemoryValue", (PyCFunction)TritonContext_clearConcreteMemoryValue, METH_VARARGS, ""},
3592 {"clearPathConstraints", (PyCFunction)TritonContext_clearPathConstraints, METH_NOARGS, ""},
3593 {"concretizeAllMemory", (PyCFunction)TritonContext_concretizeAllMemory, METH_NOARGS, ""},
3594 {"concretizeAllRegister", (PyCFunction)TritonContext_concretizeAllRegister, METH_NOARGS, ""},
3595 {"concretizeMemory", (PyCFunction)TritonContext_concretizeMemory, METH_O, ""},
3596 {"concretizeRegister", (PyCFunction)TritonContext_concretizeRegister, METH_O, ""},
3597 {"createSymbolicMemoryExpression", (PyCFunction)TritonContext_createSymbolicMemoryExpression, METH_VARARGS, ""},
3598 {"createSymbolicRegisterExpression", (PyCFunction)TritonContext_createSymbolicRegisterExpression, METH_VARARGS, ""},
3599 {"createSymbolicVolatileExpression", (PyCFunction)TritonContext_createSymbolicVolatileExpression, METH_VARARGS, ""},
3600 {"disassembly", (PyCFunction)TritonContext_disassembly, METH_VARARGS, ""},
3601 {"evaluateAstViaSolver", (PyCFunction)TritonContext_evaluateAstViaSolver, METH_O, ""},
3602 {"getAllRegisters", (PyCFunction)TritonContext_getAllRegisters, METH_NOARGS, ""},
3603 {"getArchitecture", (PyCFunction)TritonContext_getArchitecture, METH_NOARGS, ""},
3604 {"getAstContext", (PyCFunction)TritonContext_getAstContext, METH_NOARGS, ""},
3605 {"getAstRepresentationMode", (PyCFunction)TritonContext_getAstRepresentationMode, METH_NOARGS, ""},
3606 {"getConcreteMemoryAreaValue", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_getConcreteMemoryAreaValue, METH_VARARGS | METH_KEYWORDS, ""},
3607 {"getConcreteMemoryValue", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_getConcreteMemoryValue, METH_VARARGS | METH_KEYWORDS, ""},
3608 {"getConcreteRegisterValue", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_getConcreteRegisterValue, METH_VARARGS | METH_KEYWORDS, ""},
3609 {"getConcreteVariableValue", (PyCFunction)TritonContext_getConcreteVariableValue, METH_O, ""},
3610 {"getGprBitSize", (PyCFunction)TritonContext_getGprBitSize, METH_NOARGS, ""},
3611 {"getGprSize", (PyCFunction)TritonContext_getGprSize, METH_NOARGS, ""},
3612 {"getImmediateAst", (PyCFunction)TritonContext_getImmediateAst, METH_O, ""},
3613 {"getMemoryAst", (PyCFunction)TritonContext_getMemoryAst, METH_O, ""},
3614 {"getModel", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_getModel, METH_VARARGS | METH_KEYWORDS, ""},
3615 {"getModels", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_getModels, METH_VARARGS | METH_KEYWORDS, ""},
3616 {"getParentRegister", (PyCFunction)TritonContext_getParentRegister, METH_O, ""},
3617 {"getParentRegisters", (PyCFunction)TritonContext_getParentRegisters, METH_NOARGS, ""},
3618 {"getPathConstraints", (PyCFunction)TritonContext_getPathConstraints, METH_NOARGS, ""},
3619 {"getPathPredicate", (PyCFunction)TritonContext_getPathPredicate, METH_NOARGS, ""},
3620 {"getPathPredicateSize", (PyCFunction)TritonContext_getPathPredicateSize, METH_NOARGS, ""},
3621 {"getPredicatesToReachAddress", (PyCFunction)TritonContext_getPredicatesToReachAddress, METH_O, ""},
3622 {"getRegister", (PyCFunction)TritonContext_getRegister, METH_O, ""},
3623 {"getRegisterAst", (PyCFunction)TritonContext_getRegisterAst, METH_O, ""},
3624 {"getSolver", (PyCFunction)TritonContext_getSolver, METH_NOARGS, ""},
3625 {"getSymbolicExpression", (PyCFunction)TritonContext_getSymbolicExpression, METH_O, ""},
3626 {"getSymbolicExpressions", (PyCFunction)TritonContext_getSymbolicExpressions, METH_NOARGS, ""},
3627 {"getSymbolicMemory", (PyCFunction)TritonContext_getSymbolicMemory, METH_VARARGS, ""},
3628 {"getSymbolicMemoryValue", (PyCFunction)TritonContext_getSymbolicMemoryValue, METH_O, ""},
3629 {"getSymbolicRegister", (PyCFunction)TritonContext_getSymbolicRegister, METH_O, ""},
3630 {"getSymbolicRegisterValue", (PyCFunction)TritonContext_getSymbolicRegisterValue, METH_O, ""},
3631 {"getSymbolicRegisters", (PyCFunction)TritonContext_getSymbolicRegisters, METH_NOARGS, ""},
3632 {"getSymbolicVariable", (PyCFunction)TritonContext_getSymbolicVariable, METH_O, ""},
3633 {"getSymbolicVariables", (PyCFunction)TritonContext_getSymbolicVariables, METH_NOARGS, ""},
3634 {"getTaintedMemory", (PyCFunction)TritonContext_getTaintedMemory, METH_NOARGS, ""},
3635 {"getTaintedRegisters", (PyCFunction)TritonContext_getTaintedRegisters, METH_NOARGS, ""},
3636 {"getTaintedSymbolicExpressions", (PyCFunction)TritonContext_getTaintedSymbolicExpressions, METH_NOARGS, ""},
3637 {"initLeaAst", (PyCFunction)TritonContext_initLeaAst, METH_O, ""},
3638 {"isArchitectureValid", (PyCFunction)TritonContext_isArchitectureValid, METH_NOARGS, ""},
3639 {"isConcreteMemoryValueDefined", (PyCFunction)TritonContext_isConcreteMemoryValueDefined, METH_VARARGS, ""},
3640 {"isFlag", (PyCFunction)TritonContext_isFlag, METH_O, ""},
3641 {"isMemorySymbolized", (PyCFunction)TritonContext_isMemorySymbolized, METH_O, ""},
3642 {"isMemoryTainted", (PyCFunction)TritonContext_isMemoryTainted, METH_O, ""},
3643 {"isModeEnabled", (PyCFunction)TritonContext_isModeEnabled, METH_O, ""},
3644 {"isRegister", (PyCFunction)TritonContext_isRegister, METH_O, ""},
3645 {"isRegisterSymbolized", (PyCFunction)TritonContext_isRegisterSymbolized, METH_O, ""},
3646 {"isRegisterTainted", (PyCFunction)TritonContext_isRegisterTainted, METH_O, ""},
3647 {"isRegisterValid", (PyCFunction)TritonContext_isRegisterValid, METH_O, ""},
3648 {"isSat", (PyCFunction)TritonContext_isSat, METH_O, ""},
3649 {"isSymbolicExpressionExists", (PyCFunction)TritonContext_isSymbolicExpressionExists, METH_O, ""},
3650 {"isThumb", (PyCFunction)TritonContext_isThumb, METH_NOARGS, ""},
3651 {"liftToDot", (PyCFunction)TritonContext_liftToDot, METH_O, ""},
3652 {"liftToLLVM", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_liftToLLVM, METH_VARARGS | METH_KEYWORDS, ""},
3653 {"liftToPython", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_liftToPython, METH_VARARGS | METH_KEYWORDS, ""},
3654 {"liftToSMT", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_liftToSMT, METH_VARARGS | METH_KEYWORDS, ""},
3655 {"newSymbolicExpression", (PyCFunction)TritonContext_newSymbolicExpression, METH_VARARGS, ""},
3656 {"newSymbolicVariable", (PyCFunction)TritonContext_newSymbolicVariable, METH_VARARGS, ""},
3657 {"popPathConstraint", (PyCFunction)TritonContext_popPathConstraint, METH_NOARGS, ""},
3658 {"processing", (PyCFunction)TritonContext_processing, METH_VARARGS, ""},
3659 {"pushPathConstraint", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_pushPathConstraint, METH_VARARGS | METH_KEYWORDS, ""},
3660 {"removeCallback", (PyCFunction)TritonContext_removeCallback, METH_VARARGS, ""},
3661 {"reset", (PyCFunction)TritonContext_reset, METH_NOARGS, ""},
3662 {"setArchitecture", (PyCFunction)TritonContext_setArchitecture, METH_O, ""},
3663 {"setAstRepresentationMode", (PyCFunction)TritonContext_setAstRepresentationMode, METH_O, ""},
3664 {"setConcreteMemoryAreaValue", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_setConcreteMemoryAreaValue, METH_VARARGS | METH_KEYWORDS, ""},
3665 {"setConcreteMemoryValue", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_setConcreteMemoryValue, METH_VARARGS | METH_KEYWORDS, ""},
3666 {"setConcreteRegisterValue", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_setConcreteRegisterValue, METH_VARARGS | METH_KEYWORDS, ""},
3667 {"setConcreteVariableValue", (PyCFunction)TritonContext_setConcreteVariableValue, METH_VARARGS, ""},
3668 {"setMode", (PyCFunction)TritonContext_setMode, METH_VARARGS, ""},
3669 {"setSolver", (PyCFunction)TritonContext_setSolver, METH_O, ""},
3670 {"setSolverMemoryLimit", (PyCFunction)TritonContext_setSolverMemoryLimit, METH_O, ""},
3671 {"setSolverTimeout", (PyCFunction)TritonContext_setSolverTimeout, METH_O, ""},
3672 {"setTaintMemory", (PyCFunction)TritonContext_setTaintMemory, METH_VARARGS, ""},
3673 {"setTaintRegister", (PyCFunction)TritonContext_setTaintRegister, METH_VARARGS, ""},
3674 {"setThumb", (PyCFunction)TritonContext_setThumb, METH_O, ""},
3675 {"simplify", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_simplify, METH_VARARGS | METH_KEYWORDS, ""},
3676 {"sliceExpressions", (PyCFunction)TritonContext_sliceExpressions, METH_O, ""},
3677 {"symbolizeExpression", (PyCFunction)TritonContext_symbolizeExpression, METH_VARARGS, ""},
3678 {"symbolizeMemory", (PyCFunction)TritonContext_symbolizeMemory, METH_VARARGS, ""},
3679 {"symbolizeRegister", (PyCFunction)TritonContext_symbolizeRegister, METH_VARARGS, ""},
3680 {"synthesize", (PyCFunction)(void*)(PyCFunctionWithKeywords)TritonContext_synthesize, METH_VARARGS | METH_KEYWORDS, ""},
3681 {"taintAssignment", (PyCFunction)TritonContext_taintAssignment, METH_VARARGS, ""},
3682 {"taintMemory", (PyCFunction)TritonContext_taintMemory, METH_O, ""},
3683 {"taintRegister", (PyCFunction)TritonContext_taintRegister, METH_O, ""},
3684 {"taintUnion", (PyCFunction)TritonContext_taintUnion, METH_VARARGS, ""},
3685 {"untaintMemory", (PyCFunction)TritonContext_untaintMemory, METH_O, ""},
3686 {"untaintRegister", (PyCFunction)TritonContext_untaintRegister, METH_O, ""},
3687 {nullptr, nullptr, 0, nullptr}
3688 };
3689
3690
3692 PyTypeObject TritonContext_Type = {
3693 PyVarObject_HEAD_INIT(&PyType_Type, 0)
3694 "TritonContext", /* tp_name */
3695 sizeof(TritonContext_Object), /* tp_basicsize */
3696 0, /* tp_itemsize */
3697 (destructor)TritonContext_dealloc, /* tp_dealloc */
3698 0, /* tp_print or tp_vectorcall_offset */
3699 0, /* tp_getattr */
3700 0, /* tp_setattr */
3701 0, /* tp_compare */
3702 0, /* tp_repr */
3703 0, /* tp_as_number */
3704 0, /* tp_as_sequence */
3705 0, /* tp_as_mapping */
3706 0, /* tp_hash */
3707 0, /* tp_call */
3708 0, /* tp_str */
3709 (getattrofunc)TritonContext_getattro, /* tp_getattro */
3710 0, /* tp_setattro */
3711 0, /* tp_as_buffer */
3712 Py_TPFLAGS_DEFAULT, /* tp_flags */
3713 "TritonContext objects", /* tp_doc */
3714 0, /* tp_traverse */
3715 0, /* tp_clear */
3716 0, /* tp_richcompare */
3717 0, /* tp_weaklistoffset */
3718 0, /* tp_iter */
3719 0, /* tp_iternext */
3720 TritonContext_callbacks, /* tp_methods */
3721 0, /* tp_members */
3722 0, /* tp_getset */
3723 0, /* tp_base */
3724 0, /* tp_dict */
3725 0, /* tp_descr_get */
3726 0, /* tp_descr_set */
3727 0, /* tp_dictoffset */
3728 0, /* tp_init */
3729 0, /* tp_alloc */
3730 0, /* tp_new */
3731 0, /* tp_free */
3732 0, /* tp_is_gc */
3733 0, /* tp_bases */
3734 0, /* tp_mro */
3735 0, /* tp_cache */
3736 0, /* tp_subclasses */
3737 0, /* tp_weaklist */
3738 0, /* tp_del */
3739 #if IS_PY3
3740 0, /* tp_version_tag */
3741 0, /* tp_finalize */
3742 #if IS_PY3_8
3743 0, /* tp_vectorcall */
3744 #if !IS_PY3_9
3745 0, /* bpo-37250: kept for backwards compatibility in CPython 3.8 only */
3746 #endif
3747 #endif
3748 #else
3749 0 /* tp_version_tag */
3750 #endif
3751 };
3752
3753
3754 PyObject* PyTritonContext(void) {
3755 PyType_Ready(&TritonContext_Type);
3756 TritonContext_Object* object = PyObject_NEW(TritonContext_Object, &TritonContext_Type);
3757
3758 if (object != nullptr) {
3759 object->ctx = new triton::Context();
3760 object->ref = false;
3761 object->regAttr = nullptr;
3762 }
3763
3764 return (PyObject*)object;
3765 }
3766
3767
3768 PyObject* PyTritonContext(triton::arch::architecture_e arch) {
3769 PyType_Ready(&TritonContext_Type);
3770 TritonContext_Object* object = PyObject_NEW(TritonContext_Object, &TritonContext_Type);
3771
3772 if (object != nullptr) {
3773 object->ctx = new triton::Context(arch);
3774 object->ref = false;
3775 object->regAttr = nullptr;
3776 }
3777
3778 return (PyObject*)object;
3779 }
3780
3781
3782 PyObject* PyTritonContextRef(triton::Context& ctx) {
3783 PyType_Ready(&TritonContext_Type);
3784 TritonContext_Object* object = PyObject_NEW(TritonContext_Object, &TritonContext_Type);
3785
3786 if (object != nullptr) {
3787 object->ctx = &ctx;
3788 object->ref = true;
3789 object->regAttr = nullptr;
3790 }
3791
3792 return (PyObject*)object;
3793 }
3794
3795 }; /* python namespace */
3796 }; /* bindings namespace */
3797}; /* triton namespace */
math::wide_integer::uintwide_t
Definition uintwide_t.h:1274
triton::Context
This is the main Triton Context class.
Definition context.hpp:45
triton::arch::Instruction
This class is used to represent an instruction.
Definition instruction.hpp:48
triton::arch::MemoryAccess
This class is used to represent a memory access.
Definition memoryAccess.hpp:40
triton::arch::Register
This class is used when an instruction has a register operand.
Definition register.hpp:44
triton::exceptions::Callbacks
The exception class used by callbacks.
Definition exceptions.hpp:437
triton::exceptions::Exception
The root class of all exceptions.
Definition exceptions.hpp:36
triton::exceptions::Exception::what
TRITON_EXPORT const char * what() const
Returns the exception message.
Definition exceptions.hpp:57
triton::arch::architecture_e
architecture_e
Definition archEnums.hpp:32
triton::arch::register_e
register_e
Types of register.
Definition archEnums.hpp:66
triton::arch::ARCH_INVALID
@ ARCH_INVALID
Definition archEnums.hpp:33
triton::ast::SharedAbstractNode
std::shared_ptr< triton::ast::AbstractNode > SharedAbstractNode
Shared Abstract Node.
Definition ast.hpp:59
triton::bitsize::flag
constexpr triton::uint32 flag
flag size in bit
Definition cpuSize.hpp:58
triton::callbacks::getConcreteRegisterValueCallback
ComparableFunctor< void(triton::Context &, const triton::arch::Register &)> getConcreteRegisterValueCallback
The prototype of a GET_CONCRETE_REGISTER_VALUE callback.
Definition callbacks.hpp:53
triton::callbacks::symbolicSimplificationCallback
ComparableFunctor< triton::ast::SharedAbstractNode(triton::Context &, const triton::ast::SharedAbstractNode &)> symbolicSimplificationCallback
The prototype of a SYMBOLIC_SIMPLIFICATION callback.
Definition callbacks.hpp:75
triton::callbacks::setConcreteRegisterValueCallback
ComparableFunctor< void(triton::Context &, const triton::arch::Register &, const triton::uint512 &value)> setConcreteRegisterValueCallback
The prototype of a SET_CONCRETE_REGISTER_VALUE callback.
Definition callbacks.hpp:67
triton::callbacks::setConcreteMemoryValueCallback
ComparableFunctor< void(triton::Context &, const triton::arch::MemoryAccess &, const triton::uint512 &value)> setConcreteMemoryValueCallback
The prototype of a SET_CONCRETE_MEMORY_VALUE callback.
Definition callbacks.hpp:60
triton::callbacks::callback_e
callback_e
Definition callbacksEnums.hpp:29
triton::callbacks::getConcreteMemoryValueCallback
ComparableFunctor< void(triton::Context &, const triton::arch::MemoryAccess &)> getConcreteMemoryValueCallback
The prototype of a GET_CONCRETE_MEMORY_VALUE callback.
Definition callbacks.hpp:46
triton::callbacks::SYMBOLIC_SIMPLIFICATION
@ SYMBOLIC_SIMPLIFICATION
Definition callbacksEnums.hpp:34
triton::callbacks::GET_CONCRETE_REGISTER_VALUE
@ GET_CONCRETE_REGISTER_VALUE
Definition callbacksEnums.hpp:31
triton::callbacks::GET_CONCRETE_MEMORY_VALUE
@ GET_CONCRETE_MEMORY_VALUE
Definition callbacksEnums.hpp:30
triton::callbacks::SET_CONCRETE_MEMORY_VALUE
@ SET_CONCRETE_MEMORY_VALUE
Definition callbacksEnums.hpp:32
triton::callbacks::SET_CONCRETE_REGISTER_VALUE
@ SET_CONCRETE_REGISTER_VALUE
Definition callbacksEnums.hpp:33
triton::modes::mode_e
mode_e
Enumerates all kinds of mode.
Definition modesEnums.hpp:29
triton::bindings::python::PyTritonContextRef
PyObject * PyTritonContextRef(triton::Context &ctx)
Creates a TritonContext python class which is a reference to another Context.
Definition pyTritonContext.cpp:3782
triton::bindings::python::xPyClass_New
PyObject * xPyClass_New(PyObject *b, PyObject *d, PyObject *n)
Creates a PyClass and raises an exception if it fails. dict is copied in Py3 ! All references are dec...
Definition pyXFunctions.cpp:53
triton::bindings::python::PyPathConstraint
PyObject * PyPathConstraint(const triton::engines::symbolic::PathConstraint &pc)
Creates the PathConstraint python class.
Definition pyPathConstraint.cpp:295
triton::bindings::python::PySymbolicVariable
PyObject * PySymbolicVariable(const triton::engines::symbolic::SharedSymbolicVariable &symVar)
Creates the SymbolicVariable python class.
Definition pySymbolicVariable.cpp:347
triton::bindings::python::PySolverModel
PyObject * PySolverModel(const triton::engines::solver::SolverModel &model)
Creates the SolverModel python class.
Definition pySolverModel.cpp:220
triton::bindings::python::PyLong_AsUint64
triton::uint64 PyLong_AsUint64(PyObject *vv)
Returns a triton::uint64 from a pyObject.
Definition utils.cpp:137
triton::bindings::python::PyLong_FromUsize
PyObject * PyLong_FromUsize(triton::usize value)
Returns a pyObject from a triton::usize.
Definition utils.cpp:288
triton::bindings::python::xPyTuple_New
PyObject * xPyTuple_New(Py_ssize_t len)
Creates a PyTuple and raises an exception if it fails.
Definition pyXFunctions.cpp:37
triton::bindings::python::xPyString_FromString
PyObject * xPyString_FromString(const char *v)
Creates a PyString and raises an exception if it fails.
Definition pyXFunctions.cpp:45
triton::bindings::python::PyLong_AsBool
bool PyLong_AsBool(PyObject *obj)
Returns a bool from a pyObject.
Definition utils.cpp:45
triton::bindings::python::PyLong_FromUint512
PyObject * PyLong_FromUint512(triton::uint512 value)
Returns a pyObject from a triton::uint512.
Definition utils.cpp:418
triton::bindings::python::PyLong_AsUint512
triton::uint512 PyLong_AsUint512(PyObject *vv)
Returns a triton::uint512 from a pyObject.
Definition utils.cpp:224
triton::bindings::python::PyAstContext
PyObject * PyAstContext(const triton::ast::SharedAstContext &actx)
Creates an AstContext python class.
Definition pyAstContext.cpp:1909
triton::bindings::python::PyBasicBlock
PyObject * PyBasicBlock(void)
Creates the BasicBlock python class.
Definition pyBasicBlock.cpp:337
triton::bindings::python::PyInstruction
PyObject * PyInstruction(void)
Creates the Instruction python class.
Definition pyInstruction.cpp:840
triton::bindings::python::xPyList_New
PyObject * xPyList_New(Py_ssize_t len)
Creates a PyList and raises an exception if it fails.
Definition pyXFunctions.cpp:29
triton::bindings::python::xPyDict_SetItem
int xPyDict_SetItem(PyObject *p, PyObject *key, PyObject *val)
Same as PyDict_SetItem but decrements reference on object and key.
Definition pyXFunctions.cpp:79
triton::bindings::python::PyLong_FromUint64
PyObject * PyLong_FromUint64(triton::uint64 value)
Returns a pyObject from a triton::uint64.
Definition utils.cpp:328
triton::bindings::python::PyRegister
PyObject * PyRegister(const triton::arch::Register &reg)
Creates the Register python class.
Definition pyRegister.cpp:453
triton::bindings::python::PyTritonContext
PyObject * PyTritonContext(void)
Creates the new TritonContext python class.
Definition pyTritonContext.cpp:3754
triton::bindings::python::PyLong_AsUint32
triton::uint32 PyLong_AsUint32(PyObject *vv)
Returns a triton::uint32 from a pyObject.
Definition utils.cpp:108
triton::bindings::python::PyLong_AsUsize
triton::usize PyLong_AsUsize(PyObject *vv)
Returns a triton::usize from a pyObject.
Definition utils.cpp:79
triton::bindings::python::PySymbolicExpression
PyObject * PySymbolicExpression(const triton::engines::symbolic::SharedSymbolicExpression &symExpr)
Creates the SymbolicExpression python class.
Definition pySymbolicExpression.cpp:414
triton::bindings::python::PyMemoryAccess
PyObject * PyMemoryAccess(const triton::arch::MemoryAccess &mem)
Creates the Memory python class.
Definition pyMemoryAccess.cpp:499
triton::bindings::python::xPyDict_New
PyObject * xPyDict_New(void)
Creates a PyDict and raises an exception if it fails.
Definition pyXFunctions.cpp:21
triton::bindings::python::PyLong_FromUint32
PyObject * PyLong_FromUint32(triton::uint32 value)
Returns a pyObject from a triton::uint32.
Definition utils.cpp:322
triton::bindings::python::PyAstNode
PyObject * PyAstNode(const triton::ast::SharedAbstractNode &node)
Creates the AstNode python class.
Definition pyAstNode.cpp:988
triton::ast::representations::mode_e
mode_e
All types of representation mode.
Definition astEnums.hpp:98
triton::engines::solver::solver_e
solver_e
Definition solverEnums.hpp:39
triton::engines::solver::status_e
status_e
Definition solverEnums.hpp:51
triton::engines::symbolic::SharedSymbolicExpression
std::shared_ptr< triton::engines::symbolic::SymbolicExpression > SharedSymbolicExpression
Shared Symbolic Expression.
Definition ast.hpp:40
triton::usize
std::size_t usize
unsigned MAX_INT 32 or 64 bits according to the CPU.
Definition tritonTypes.hpp:106
triton::uint64
std::uint64_t uint64
unisgned 64-bits
Definition tritonTypes.hpp:42
triton::uint32
std::uint32_t uint32
unisgned 32-bits
Definition tritonTypes.hpp:39
triton::uint8
std::uint8_t uint8
unisgned 8-bits
Definition tritonTypes.hpp:33
triton::bindings::python::TritonContext_Type
PyTypeObject TritonContext_Type
Description of the python representation of a TritonContext.
Definition pyTritonContext.cpp:3692
triton::bindings::python::TritonContext_callbacks
PyMethodDef TritonContext_callbacks[]
TritonContext methods.
Definition pyTritonContext.cpp:3584
triton
The Triton namespace.
Definition architecture.cpp:25
PySymbolicVariable_Check
#define PySymbolicVariable_Check(v)
Definition pythonObjects.hpp:340
PyImmediate_Check
#define PyImmediate_Check(v)
Definition pythonObjects.hpp:283
PyRegister_AsRegister
#define PyRegister_AsRegister(v)
Definition pythonObjects.hpp:322
PyMemoryAccess_Check
#define PyMemoryAccess_Check(v)
Definition pythonObjects.hpp:295
PyTritonContext_AsTritonContext
#define PyTritonContext_AsTritonContext(v)
Definition pythonObjects.hpp:310
PyInstruction_AsInstruction
#define PyInstruction_AsInstruction(v)
Definition pythonObjects.hpp:292
PyImmediate_AsImmediate
#define PyImmediate_AsImmediate(v)
Definition pythonObjects.hpp:286
PyInstruction_Check
#define PyInstruction_Check(v)
Definition pythonObjects.hpp:289
PyAstNode_Check
#define PyAstNode_Check(v)
Definition pythonObjects.hpp:331
PyMemoryAccess_AsMemoryAccess
#define PyMemoryAccess_AsMemoryAccess(v)
Definition pythonObjects.hpp:298
PyBasicBlock_AsBasicBlock
#define PyBasicBlock_AsBasicBlock(v)
Definition pythonObjects.hpp:280
PyRegister_Check
#define PyRegister_Check(v)
Definition pythonObjects.hpp:319
PyBasicBlock_Check
#define PyBasicBlock_Check(v)
Definition pythonObjects.hpp:277
PySymbolicExpression_Check
#define PySymbolicExpression_Check(v)
Definition pythonObjects.hpp:334
PySymbolicVariable_AsSymbolicVariable
#define PySymbolicVariable_AsSymbolicVariable(v)
Definition pythonObjects.hpp:343
PyAstNode_AsAstNode
#define PyAstNode_AsAstNode(v)
Definition pythonObjects.hpp:268
PySymbolicExpression_AsSymbolicExpression
#define PySymbolicExpression_AsSymbolicExpression(v)
Definition pythonObjects.hpp:337
triton::bindings::python::TritonContext_Object
pyTritonContext object.
Definition pythonObjects.hpp:205
Generated by doxygen 1.10.0