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