465 static void TritonContext_dealloc(PyObject* self) {
466 if (((TritonContext_Object*)self)->ref ==
false)
468 Py_XDECREF(((TritonContext_Object*)self)->regAttr);
469 Py_TYPE(self)->tp_free((PyObject*)self);
473 static void TritonContext_fillRegistersAttribute(PyObject* self) {
478 for (
auto& reg : regs)
481 Py_XDECREF(((TritonContext_Object*)(self))->regAttr);
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;
493 if (PyArg_ParseTuple(args,
"|OO", &mode, &function) ==
false) {
494 return PyErr_Format(PyExc_TypeError,
"TritonContext::addCallback(): Invalid number of arguments");
497 if (mode ==
nullptr || (!PyLong_Check(mode) && !PyInt_Check(mode)))
498 return PyErr_Format(PyExc_TypeError,
"TritonContext::addCallback(): Expects a CALLBACK as first argument.");
500 if (function ==
nullptr || !PyCallable_Check(function))
501 return PyErr_Format(PyExc_TypeError,
"TritonContext::addCallback(): Expects a function as second argument.");
503 if (PyMethod_Check(function)) {
504 cb_self = PyMethod_GET_SELF(function);
505 cb = PyMethod_GET_FUNCTION(function);
520 PyObject* args =
nullptr;
525 PyTuple_SetItem(args, 0, cb_self);
537 PyObject* ret = PyObject_CallObject(cb, args);
540 if (ret ==
nullptr) {
552 PyObject* args =
nullptr;
557 PyTuple_SetItem(args, 0, cb_self);
569 PyObject* ret = PyObject_CallObject(cb, args);
572 if (ret ==
nullptr) {
584 PyObject* args =
nullptr;
589 PyTuple_SetItem(args, 0, cb_self);
603 PyObject* ret = PyObject_CallObject(cb, args);
606 if (ret ==
nullptr) {
618 PyObject* args =
nullptr;
623 PyTuple_SetItem(args, 0, cb_self);
637 PyObject* ret = PyObject_CallObject(cb, args);
640 if (ret ==
nullptr) {
652 PyObject* args =
nullptr;
657 PyTuple_SetItem(args, 0, cb_self);
669 PyObject* ret = PyObject_CallObject(cb, args);
672 if (ret ==
nullptr) {
689 return PyErr_Format(PyExc_TypeError,
"Callbacks::addCallback(): Invalid kind of callback.");
696 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
704 static PyObject* TritonContext_assignSymbolicExpressionToMemory(PyObject* self, PyObject* args) {
705 PyObject* se =
nullptr;
706 PyObject* mem =
nullptr;
709 if (PyArg_ParseTuple(args,
"|OO", &se, &mem) ==
false) {
710 return PyErr_Format(PyExc_TypeError,
"TritonContext::assignSymbolicExpressionToMemory(): Invalid number of arguments");
714 return PyErr_Format(PyExc_TypeError,
"TritonContext::assignSymbolicExpressionToMemory(): Expects a SymbolicExpression as first argument.");
717 return PyErr_Format(PyExc_TypeError,
"TritonContext::assignSymbolicExpressionToMemory(): Expects a MemoryAccess as second argument.");
729 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
737 static PyObject* TritonContext_assignSymbolicExpressionToRegister(PyObject* self, PyObject* args) {
738 PyObject* se =
nullptr;
739 PyObject* reg =
nullptr;
742 if (PyArg_ParseTuple(args,
"|OO", &se, ®) ==
false) {
743 return PyErr_Format(PyExc_TypeError,
"TritonContext::assignSymbolicExpressionToRegister(): Invalid number of arguments");
747 return PyErr_Format(PyExc_TypeError,
"TritonContext::assignSymbolicExpressionToRegister(): Expects a SymbolicExpression as first argument.");
750 return PyErr_Format(PyExc_TypeError,
"TritonContext::assignSymbolicExpressionToRegister(): Expects a Register as second argument.");
762 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
770 static PyObject* TritonContext_buildSemantics(PyObject* self, PyObject* inst) {
772 return PyErr_Format(PyExc_TypeError,
"TritonContext::buildSemantics(): Expects an Instruction as argument.");
781 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
786 static PyObject* TritonContext_clearCallbacks(PyObject* self, PyObject* noarg) {
794 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
802 static PyObject* TritonContext_clearModes(PyObject* self, PyObject* noarg) {
810 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
818 static PyObject* TritonContext_clearConcreteMemoryValue(PyObject* self, PyObject* args) {
819 PyObject* baseAddr =
nullptr;
820 PyObject* size =
nullptr;
823 if (PyArg_ParseTuple(args,
"|OO", &baseAddr, &size) ==
false) {
824 return PyErr_Format(PyExc_TypeError,
"TritonContext::clearConcreteMemoryValue(): Invalid number of arguments");
831 else if (baseAddr && (PyLong_Check(baseAddr) || PyInt_Check(baseAddr))) {
832 if (size && (PyLong_Check(size) || PyInt_Check(size))) {
836 return PyErr_Format(PyExc_TypeError,
"TritonContext::clearConcreteMemoryValue(): Expects a size (integer) as second argument.");
840 return PyErr_Format(PyExc_TypeError,
"TritonContext::clearConcreteMemoryValue(): Expects a base address (integer) as arguments or a memory cells.");
847 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
855 static PyObject* TritonContext_clearPathConstraints(PyObject* self, PyObject* noarg) {
860 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
868 static PyObject* TritonContext_concretizeAllMemory(PyObject* self, PyObject* noarg) {
876 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
884 static PyObject* TritonContext_concretizeAllRegister(PyObject* self, PyObject* noarg) {
892 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
900 static PyObject* TritonContext_concretizeMemory(PyObject* self, PyObject* mem) {
902 if (PyLong_Check(mem) || PyInt_Check(mem)) {
910 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
923 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
929 return PyErr_Format(PyExc_TypeError,
"TritonContext::concretizeMemory(): Expects an integer or MemoryAccess as argument.");
936 static PyObject* TritonContext_concretizeRegister(PyObject* self, PyObject* reg) {
938 return PyErr_Format(PyExc_TypeError,
"TritonContext::concretizeRegister(): Expects a Register as argument.");
947 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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 =
"";
963 if (PyArg_ParseTuple(args,
"|OOOO", &inst, &node, &mem, &comment) ==
false) {
964 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicMemoryExpression(): Invalid number of arguments");
968 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicMemoryExpression(): Expects an Instruction as first argument.");
971 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicMemoryExpression(): Expects a AstNode as second argument.");
974 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicMemoryExpression(): Expects a MemoryAccess as third argument.");
976 if (comment !=
nullptr && !PyStr_Check(comment))
977 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicMemoryExpression(): Expects a sting as fourth argument.");
979 if (comment !=
nullptr)
980 ccomment = PyStr_AsString(comment);
993 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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 =
"";
1006 if (PyArg_ParseTuple(args,
"|OOOO", &inst, &node, ®, &comment) ==
false) {
1007 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicRegisterExpression(): Invalid number of arguments");
1011 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicRegisterExpression(): Expects an Instruction as first argument.");
1014 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicRegisterExpression(): Expects a AstNode as second argument.");
1017 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicRegisterExpression(): Expects a Register as third argument.");
1019 if (comment !=
nullptr && !PyStr_Check(comment))
1020 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicRegisterExpression(): Expects a sting as fourth argument.");
1022 if (comment !=
nullptr)
1023 ccomment = PyStr_AsString(comment);
1036 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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 =
"";
1048 if (PyArg_ParseTuple(args,
"|OOO", &inst, &node, &comment) ==
false) {
1049 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicVolatileExpression(): Invalid number of arguments");
1053 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicVolatileExpression(): Expects an Instruction as first argument.");
1056 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicVolatileExpression(): Expects a AstNode as second argument.");
1058 if (comment !=
nullptr && !PyStr_Check(comment))
1059 return PyErr_Format(PyExc_TypeError,
"TritonContext::createSymbolicVolatileExpression(): Expects a sting as third argument.");
1061 if (comment !=
nullptr)
1062 ccomment = PyStr_AsString(comment);
1074 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1079 static PyObject* TritonContext_disassembly(PyObject* self, PyObject* args) {
1080 PyObject* arg0 =
nullptr;
1081 PyObject* arg1 =
nullptr;
1082 PyObject* ret =
nullptr;
1086 if (PyArg_ParseTuple(args,
"|OO", &arg0, &arg1) ==
false) {
1087 return PyErr_Format(PyExc_TypeError,
"TritonContext::disassembly(): Invalid number of arguments.");
1098 if (arg1 !=
nullptr && (PyLong_Check(arg1) || PyInt_Check(arg1))) {
1105 if ((arg0 !=
nullptr && (PyLong_Check(arg0) || PyInt_Check(arg0))) &&
1106 (arg1 ==
nullptr || PyLong_Check(arg1) || PyInt_Check(arg1))) {
1108 std::vector<triton::arch::Instruction> insts;
1112 for (
auto& inst : insts)
1121 return PyErr_Format(PyExc_TypeError,
"TritonContext::disassembly(): Expects an Instruction or two integers as arguments.");
1128 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1133 static PyObject* TritonContext_evaluateAstViaSolver(PyObject* self, PyObject* node) {
1135 return PyErr_Format(PyExc_TypeError,
"TritonContext::evaluateAstViaSolver(): Expects a AstNode as argument.");
1144 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1152 static PyObject* TritonContext_getAllRegisters(PyObject* self, PyObject* noarg) {
1153 PyObject* ret =
nullptr;
1160 for (
auto& reg: regs)
1161 PyList_SetItem(ret, index++,
PyRegister(reg.second));
1167 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1174 static PyObject* TritonContext_getArchitecture(PyObject* self, PyObject* noarg) {
1182 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1187 static PyObject* TritonContext_getAstContext(PyObject* self, PyObject* noarg) {
1195 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1200 static PyObject* TritonContext_getAstRepresentationMode(PyObject* self, PyObject* noarg) {
1208 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1213 static PyObject* TritonContext_getConcreteMemoryAreaValue(PyObject* self, PyObject* args, PyObject* kwargs) {
1215 PyObject* ret =
nullptr;
1216 PyObject* addr =
nullptr;
1217 PyObject* size =
nullptr;
1218 PyObject* execCallbacks =
nullptr;
1220 static char* 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");
1232 if (addr ==
nullptr || (!PyLong_Check(addr) && !PyInt_Check(addr))) {
1233 return PyErr_Format(PyExc_TypeError,
"TritonContext::getConcreteMemoryAreaValue(): Expects an integer as addr keyword.");
1236 if (size ==
nullptr || (!PyLong_Check(size) && !PyInt_Check(size))) {
1237 return PyErr_Format(PyExc_TypeError,
"TritonContext::getConcreteMemoryAreaValue(): Expects an integer as size keyword.");
1240 if (execCallbacks !=
nullptr && !PyBool_Check(execCallbacks)) {
1241 return PyErr_Format(PyExc_TypeError,
"TritonContext::getConcreteMemoryAreaValue(): Expects a boolean as execCallbacks keyword.");
1244 if (execCallbacks ==
nullptr) {
1253 area[index] = vv[index];
1255 ret = PyBytes_FromStringAndSize(
reinterpret_cast<const char*
>(area), vv.size());
1264 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1271 static PyObject* TritonContext_getConcreteMemoryValue(PyObject* self, PyObject* args, PyObject* kwargs) {
1272 PyObject* mem =
nullptr;
1273 PyObject* execCallbacks =
nullptr;
1275 static char* keywords[] = {
1282 if (PyArg_ParseTupleAndKeywords(args, kwargs,
"O|O", keywords, &mem, &execCallbacks) ==
false) {
1283 return PyErr_Format(PyExc_TypeError,
"TritonContext::getConcreteMemoryValue(): Invalid keyword argument");
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.");
1290 if (execCallbacks !=
nullptr && !PyBool_Check(execCallbacks)) {
1291 return PyErr_Format(PyExc_TypeError,
"TritonContext::getConcreteMemoryValue(): Expects a boolean as execCallbacks keyword.");
1294 if (execCallbacks ==
nullptr) {
1299 if (PyLong_Check(mem) || PyInt_Check(mem))
1304 return PyErr_Format(PyExc_TypeError,
"TritonContext::getConcreteMemoryValue(): Something wrong.");
1310 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1315 static PyObject* TritonContext_getConcreteRegisterValue(PyObject* self, PyObject* args, PyObject* kwargs) {
1316 PyObject* reg =
nullptr;
1317 PyObject* execCallbacks =
nullptr;
1319 static char* keywords[] = {
1326 if (PyArg_ParseTupleAndKeywords(args, kwargs,
"O|O", keywords, ®, &execCallbacks) ==
false) {
1327 return PyErr_Format(PyExc_TypeError,
"TritonContext::getConcreteRegisterValue(): Invalid keyword argument");
1331 return PyErr_Format(PyExc_TypeError,
"TritonContext::getConcreteRegisterValue(): Expects a Register as reg keyword.");
1334 if (execCallbacks !=
nullptr && !PyBool_Check(execCallbacks)) {
1335 return PyErr_Format(PyExc_TypeError,
"TritonContext::getConcreteRegisterValue(): Expects a boolean as execCallbacks keyword.");
1338 if (execCallbacks ==
nullptr) {
1349 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1354 static PyObject* TritonContext_getConcreteVariableValue(PyObject* self, PyObject* symVar) {
1356 return PyErr_Format(PyExc_TypeError,
"TritonContext::getConcreteVariableValue(): Expects a SymbolicVariable as argument.");
1365 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1370 static PyObject* TritonContext_getGprBitSize(PyObject* self, PyObject* noarg) {
1378 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1383 static PyObject* TritonContext_getGprSize(PyObject* self, PyObject* noarg) {
1391 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1396 static PyObject* TritonContext_getImmediateAst(PyObject* self, PyObject* imm) {
1398 return PyErr_Format(PyExc_TypeError,
"TritonContext::getImmediateAst(): Expects an Immediate as argument.");
1407 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1412 static PyObject* TritonContext_getMemoryAst(PyObject* self, PyObject* mem) {
1414 return PyErr_Format(PyExc_TypeError,
"TritonContext::getMemoryAst(): Expects an MemoryAccess as argument.");
1423 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1428 static PyObject* TritonContext_getModel(PyObject* self, PyObject* args, PyObject* kwargs) {
1433 PyObject* dict =
nullptr;
1434 PyObject* node =
nullptr;
1435 PyObject* wb =
nullptr;
1436 PyObject* timeout =
nullptr;
1438 static char* keywords[] = {
1446 if (PyArg_ParseTupleAndKeywords(args, kwargs,
"|OOO", keywords, &node, &wb, &timeout) ==
false) {
1447 return PyErr_Format(PyExc_TypeError,
"TritonContext::getModel(): Invalid keyword argument.");
1451 return PyErr_Format(PyExc_TypeError,
"TritonContext::getModel(): Expects a AstNode as node argument.");
1454 if (wb !=
nullptr && !PyBool_Check(wb)) {
1455 return PyErr_Format(PyExc_TypeError,
"TritonContext::getModel(): Expects a boolean as status keyword.");
1458 if (timeout !=
nullptr && (!PyLong_Check(timeout) && !PyInt_Check(timeout))) {
1459 return PyErr_Format(PyExc_TypeError,
"TritonContext::getModel(): Expects a integer as timeout keyword.");
1462 if (timeout !=
nullptr) {
1469 for (
auto it = model.begin(); it != model.end(); it++) {
1477 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1482 PyTuple_SetItem(tuple, 0, dict);
1492 static PyObject* TritonContext_getModels(PyObject* self, PyObject* args, PyObject* kwargs) {
1497 PyObject* ret =
nullptr;
1498 PyObject* node =
nullptr;
1499 PyObject* limit =
nullptr;
1500 PyObject* wb =
nullptr;
1501 PyObject* timeout =
nullptr;
1503 static char* 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.");
1517 return PyErr_Format(PyExc_TypeError,
"TritonContext::getModels(): Expects a AstNode as node argument.");
1520 if (limit ==
nullptr || (!PyLong_Check(limit) && !PyInt_Check(limit))) {
1521 return PyErr_Format(PyExc_TypeError,
"TritonContext::getModels(): Expects an integer as limit argument.");
1524 if (wb !=
nullptr && !PyBool_Check(wb)) {
1525 return PyErr_Format(PyExc_TypeError,
"TritonContext::getModels(): Expects a boolean as status keyword.");
1528 if (timeout !=
nullptr && (!PyLong_Check(timeout) && !PyInt_Check(timeout))) {
1529 return PyErr_Format(PyExc_TypeError,
"TritonContext::getModels(): Expects a integer as timeout keyword.");
1532 if (timeout !=
nullptr) {
1541 for (
auto it = models.begin(); it != models.end(); it++) {
1545 for (
auto it2 = model.begin(); it2 != model.end(); it2++) {
1548 if (model.size() > 0)
1549 PyList_SetItem(ret, index++, mdict);
1556 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1561 PyTuple_SetItem(tuple, 0, ret);
1571 static PyObject* TritonContext_getParentRegisters(PyObject* self, PyObject* noarg) {
1572 PyObject* ret =
nullptr;
1579 for (
const auto* reg: regs) {
1580 PyList_SetItem(ret, index++,
PyRegister(*reg));
1587 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1594 static PyObject* TritonContext_getPathConstraints(PyObject* self, PyObject* noarg) {
1595 PyObject* ret =
nullptr;
1602 for (
auto it = pc.begin(); it != pc.end(); it++) {
1610 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1617 static PyObject* TritonContext_getPathPredicate(PyObject* self, PyObject* noarg) {
1625 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1630 static PyObject* TritonContext_getPathPredicateSize(PyObject* self, PyObject* noarg) {
1639 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1644 static PyObject* TritonContext_getPredicatesToReachAddress(PyObject* self, PyObject* addr) {
1645 PyObject* ret =
nullptr;
1647 if (addr ==
nullptr || (!PyLong_Check(addr) && !PyInt_Check(addr)))
1648 return PyErr_Format(PyExc_TypeError,
"TritonContext::getPredicatesToReachAddress(): Expects an address as argument.");
1655 for (
auto it = preds.begin(); it != preds.end(); it++) {
1656 PyList_SetItem(ret, index++,
PyAstNode(*it));
1663 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1670 static PyObject* TritonContext_getRegister(PyObject* self, PyObject* regIn) {
1672 if (regIn !=
nullptr && (PyLong_Check(regIn) || PyInt_Check(regIn))) {
1678 else if (regIn !=
nullptr && (PyStr_Check(regIn))) {
1679 std::string name = std::string(PyStr_AsString(regIn));
1685 return PyErr_Format(PyExc_TypeError,
"TritonContext::getRegister(): Expects an integer or a string as argument.");
1692 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1697 static PyObject* TritonContext_getRegisterAst(PyObject* self, PyObject* reg) {
1699 return PyErr_Format(PyExc_TypeError,
"TritonContext::getRegisterAst(): Expects an Register as argument.");
1708 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1713 static PyObject* TritonContext_getSolver(PyObject* self, PyObject* noarg) {
1721 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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.");
1737 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1742 static PyObject* TritonContext_getSymbolicExpressions(PyObject* self, PyObject* noarg) {
1743 PyObject* ret =
nullptr;
1749 for (
auto it = expressions.begin(); it != expressions.end(); it++)
1756 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1763 static PyObject* TritonContext_getSymbolicMemory(PyObject* self, PyObject* args) {
1764 PyObject* ret =
nullptr;
1765 PyObject* addr =
nullptr;
1768 if (PyArg_ParseTuple(args,
"|O", &addr) ==
false) {
1769 return PyErr_Format(PyExc_TypeError,
"TritonContext::getSymbolicMemory(): Invalid number of arguments");
1773 if (addr ==
nullptr) {
1777 for (
auto it = regs.begin(); it != regs.end(); it++) {
1781 else if (addr !=
nullptr && (PyLong_Check(addr) || PyInt_Check(addr))) {
1785 return PyErr_Format(PyExc_TypeError,
"TritonContext::getSymbolicMemory(): Expects an integer or nothing as argument.");
1791 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1798 static PyObject* TritonContext_getSymbolicMemoryValue(PyObject* self, PyObject* mem) {
1800 return PyErr_Format(PyExc_TypeError,
"TritonContext::getSymbolicMemoryValue(): Expects an integer or a MemoryAccess as argument.");
1803 if (PyLong_Check(mem) || PyInt_Check(mem))
1811 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1816 static PyObject* TritonContext_getSymbolicRegisters(PyObject* self, PyObject* noarg) {
1817 PyObject* ret =
nullptr;
1823 for (
auto it = regs.begin(); it != regs.end(); it++) {
1831 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1838 static PyObject* TritonContext_getSymbolicRegister(PyObject* self, PyObject* reg) {
1840 return PyErr_Format(PyExc_TypeError,
"TritonContext::getSymbolicRegister(): Expects a Register as argument.");
1849 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1854 static PyObject* TritonContext_getSymbolicRegisterValue(PyObject* self, PyObject* reg) {
1856 return PyErr_Format(PyExc_TypeError,
"TritonContext::getSymbolicRegisterValue(): Expects a Register as argument.");
1865 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1870 static PyObject* TritonContext_getSymbolicVariable(PyObject* self, PyObject* arg) {
1872 if (PyLong_Check(arg) || PyInt_Check(arg))
1875 else if (PyStr_Check(arg))
1879 return PyErr_Format(PyExc_TypeError,
"TritonContext::getSymbolicVariable(): Expects an integer or a string as argument.");
1885 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1890 static PyObject* TritonContext_getSymbolicVariables(PyObject* self, PyObject* noarg) {
1891 PyObject* ret =
nullptr;
1897 for (
auto sv: variables)
1904 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1911 static PyObject* TritonContext_getTaintedMemory(PyObject* self, PyObject* noarg) {
1912 PyObject* ret =
nullptr;
1918 size = addresses.size();
1920 for (
auto it = addresses.begin(); it != addresses.end(); it++) {
1929 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1936 static PyObject* TritonContext_getTaintedRegisters(PyObject* self, PyObject* noarg) {
1937 PyObject* ret =
nullptr;
1943 size = registers.size();
1945 for (
const auto* reg: registers) {
1946 PyList_SetItem(ret, index,
PyRegister(*reg));
1954 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1961 static PyObject* TritonContext_getTaintedSymbolicExpressions(PyObject* self, PyObject* noarg) {
1962 PyObject* ret =
nullptr;
1968 size = expressions.size();
1970 for (
auto it = expressions.begin(); it != expressions.end(); it++) {
1979 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
1986 static PyObject* TritonContext_isArchitectureValid(PyObject* self, PyObject* noarg) {
1996 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2001 static PyObject* TritonContext_isConcreteMemoryValueDefined(PyObject* self, PyObject* args) {
2002 PyObject* baseAddr =
nullptr;
2003 PyObject* size =
nullptr;
2006 if (PyArg_ParseTuple(args,
"|OO", &baseAddr, &size) ==
false) {
2007 return PyErr_Format(PyExc_TypeError,
"TritonContext::isConcreteMemoryValueDefined(): Invalid number of arguments");
2016 else if (baseAddr && (PyLong_Check(baseAddr) || PyInt_Check(baseAddr))) {
2017 if (size && (PyLong_Check(size) || PyInt_Check(size))) {
2023 return PyErr_Format(PyExc_TypeError,
"TritonContext::isConcreteMemoryValueDefined(): Expects a size (integer) as second argument.");
2027 return PyErr_Format(PyExc_TypeError,
"TritonContext::isConcreteMemoryValueDefined(): Expects a base address (integer) as arguments or a memory cells.");
2034 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2039 static PyObject* TritonContext_isFlag(PyObject* self, PyObject* reg) {
2041 return PyErr_Format(PyExc_TypeError,
"TritonContext::isFlag(): Expects a Register as argument.");
2052 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2057 static PyObject* TritonContext_isMemorySymbolized(PyObject* self, PyObject* mem) {
2064 else if (PyLong_Check(mem) || PyInt_Check(mem)) {
2070 return PyErr_Format(PyExc_TypeError,
"TritonContext::isMemorySymbolized(): Expects a MemoryAccess or an integer as argument.");
2076 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2083 static PyObject* TritonContext_isMemoryTainted(PyObject* self, PyObject* mem) {
2090 else if (PyLong_Check(mem) || PyInt_Check(mem)) {
2096 return PyErr_Format(PyExc_TypeError,
"TritonContext::isMemoryTainted(): Expects a MemoryAccess or an integer as argument.");
2102 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2109 static PyObject* TritonContext_isRegister(PyObject* self, PyObject* reg) {
2111 return PyErr_Format(PyExc_TypeError,
"TritonContext::isRegister(): Expects a Register as argument.");
2122 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2127 static PyObject* TritonContext_isRegisterSymbolized(PyObject* self, PyObject* reg) {
2129 return PyErr_Format(PyExc_TypeError,
"TritonContext::isRegisterSymbolized(): Expects a Register as argument.");
2140 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2145 static PyObject* TritonContext_isRegisterTainted(PyObject* self, PyObject* reg) {
2147 return PyErr_Format(PyExc_TypeError,
"TritonContext::isRegisterTainted(): Expects a Register as argument.");
2158 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2163 static PyObject* TritonContext_isRegisterValid(PyObject* self, PyObject* reg) {
2165 return PyErr_Format(PyExc_TypeError,
"TritonContext::isRegisterValid(): Expects a Register as argument.");
2176 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2181 static PyObject* TritonContext_isSat(PyObject* self, PyObject* node) {
2183 return PyErr_Format(PyExc_TypeError,
"TritonContext::isSat(): Expects a AstNode as argument.");
2194 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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.");
2212 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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.");
2230 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2235 static PyObject* TritonContext_isThumb(PyObject* self, PyObject* noarg) {
2245 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2250 static PyObject* TritonContext_liftToDot(PyObject* self, PyObject* node) {
2252 return PyErr_Format(PyExc_TypeError,
"TritonContext::liftToDot(): Expects an AstNode or a SymbolicExpression as first argument.");
2255 std::ostringstream stream;
2270 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2278 static PyObject* TritonContext_liftToLLVM(PyObject* self, PyObject* args, PyObject* kwargs) {
2279 PyObject* node =
nullptr;
2280 PyObject* fname =
nullptr;
2281 PyObject* optimize =
nullptr;
2283 static char* 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");
2296 return PyErr_Format(PyExc_TypeError,
"TritonContext::liftToLLVM(): Expects a SymbolicExpression or a AstNode as node argument.");
2298 if (fname !=
nullptr && !PyStr_Check(fname))
2299 return PyErr_Format(PyExc_TypeError,
"TritonContext::liftToLLVM(): Expects a string as fname argument.");
2301 if (optimize !=
nullptr && !PyBool_Check(optimize))
2302 return PyErr_Format(PyExc_TypeError,
"TritonContext::liftToLLVM(): Expects a boolean as optimize argument.");
2304 if (fname ==
nullptr)
2305 fname = PyStr_FromString(
"__triton");
2307 if (optimize ==
nullptr)
2311 std::ostringstream stream;
2324 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2332 static PyObject* TritonContext_liftToPython(PyObject* self, PyObject* args, PyObject* kwargs) {
2333 PyObject* expr =
nullptr;
2334 PyObject* icomment =
nullptr;
2336 static char* keywords[] = {
2343 if (PyArg_ParseTupleAndKeywords(args, kwargs,
"|OO", keywords, &expr, &icomment) ==
false) {
2344 return PyErr_Format(PyExc_TypeError,
"TritonContext::liftToPython(): Invalid number of arguments");
2348 return PyErr_Format(PyExc_TypeError,
"TritonContext::liftToPython(): Expects a SymbolicExpression as expr argument.");
2350 if (icomment !=
nullptr && !PyBool_Check(icomment))
2351 return PyErr_Format(PyExc_TypeError,
"TritonContext::liftToPython(): Expects a boolean as icomment argument.");
2353 if (icomment ==
nullptr)
2357 std::ostringstream stream;
2365 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2373 static PyObject* TritonContext_liftToSMT(PyObject* self, PyObject* args, PyObject* kwargs) {
2374 PyObject* expr =
nullptr;
2375 PyObject* assert =
nullptr;
2376 PyObject* icomment =
nullptr;
2378 static char* 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");
2391 return PyErr_Format(PyExc_TypeError,
"TritonContext::liftToSMT(): Expects a SymbolicExpression as expr argument.");
2393 if (assert !=
nullptr && !PyBool_Check(assert))
2394 return PyErr_Format(PyExc_TypeError,
"TritonContext::liftToSMT(): Expects a boolean as assert_ argument.");
2396 if (assert ==
nullptr)
2399 if (icomment !=
nullptr && !PyBool_Check(icomment))
2400 return PyErr_Format(PyExc_TypeError,
"TritonContext::liftToSMT(): Expects a boolean as icomment argument.");
2402 if (icomment ==
nullptr)
2406 std::ostringstream stream;
2414 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2422 static PyObject* TritonContext_newSymbolicExpression(PyObject* self, PyObject* args) {
2423 PyObject* node =
nullptr;
2424 PyObject* comment =
nullptr;
2425 std::string ccomment =
"";
2428 if (PyArg_ParseTuple(args,
"|OO", &node, &comment) ==
false) {
2429 return PyErr_Format(PyExc_TypeError,
"TritonContext::newSymbolicExpression(): Invalid number of arguments");
2433 return PyErr_Format(PyExc_TypeError,
"TritonContext::newSymbolicExpression(): Expects a AstNode as first argument.");
2435 if (comment !=
nullptr && !PyStr_Check(comment))
2436 return PyErr_Format(PyExc_TypeError,
"TritonContext::newSymbolicExpression(): Expects a sting as second argument.");
2438 if (comment !=
nullptr)
2439 ccomment = PyStr_AsString(comment);
2448 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2453 static PyObject* TritonContext_newSymbolicVariable(PyObject* self, PyObject* args) {
2454 PyObject* size =
nullptr;
2455 PyObject* alias =
nullptr;
2456 std::string calias =
"";
2459 if (PyArg_ParseTuple(args,
"|OO", &size, &alias) ==
false) {
2460 return PyErr_Format(PyExc_TypeError,
"TritonContext::newSymbolicVariable(): Invalid number of arguments");
2463 if (size ==
nullptr || (!PyLong_Check(size) && !PyInt_Check(size)))
2464 return PyErr_Format(PyExc_TypeError,
"TritonContext::newSymbolicVariable(): Expects an integer as first argument.");
2466 if (alias !=
nullptr && !PyStr_Check(alias))
2467 return PyErr_Format(PyExc_TypeError,
"TritonContext::newSymbolicVariable(): Expects a sting as second argument.");
2469 if (alias !=
nullptr)
2470 calias = PyStr_AsString(alias);
2479 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2484 static PyObject* TritonContext_popPathConstraint(PyObject* self, PyObject* noarg) {
2492 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2499 static PyObject* TritonContext_processing(PyObject* self, PyObject* args) {
2500 PyObject* obj =
nullptr;
2501 PyObject* addr =
nullptr;
2504 if (PyArg_ParseTuple(args,
"|OO", &obj, &addr) ==
false) {
2505 return PyErr_Format(PyExc_TypeError,
"TritonContext::processing(): Invalid number of arguments");
2514 if (addr !=
nullptr && (PyLong_Check(addr) || PyInt_Check(addr))) {
2519 return PyErr_Format(PyExc_TypeError,
"TritonContext::processing(): Expects an Instruction or a BasicBlock as argument.");
2525 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2530 static PyObject* TritonContext_pushPathConstraint(PyObject* self, PyObject* args, PyObject* kwargs) {
2531 PyObject* node =
nullptr;
2532 PyObject* comment =
nullptr;
2533 std::string ccomment =
"";
2535 static char* keywords[] = {
2542 if (PyArg_ParseTupleAndKeywords(args, kwargs,
"|OO", keywords, &node, &comment) ==
false) {
2543 return PyErr_Format(PyExc_TypeError,
"TritonContext::pushPathConstraint(): Invalid keyword argument.");
2547 return PyErr_Format(PyExc_TypeError,
"TritonContext::pushPathConstraint(): Expects an AstNode as first argument.");
2549 if (comment !=
nullptr && !PyStr_Check(comment))
2550 return PyErr_Format(PyExc_TypeError,
"TritonContext::pushPathConstraint(): Expects a string as second argument.");
2552 if (comment !=
nullptr)
2553 ccomment = PyStr_AsString(comment);
2562 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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;
2577 if (PyArg_ParseTuple(args,
"|OO", &mode, &function) ==
false) {
2578 return PyErr_Format(PyExc_TypeError,
"TritonContext::removeCallback(): Invalid number of arguments");
2581 if (mode ==
nullptr || (!PyLong_Check(mode) && !PyInt_Check(mode)))
2582 return PyErr_Format(PyExc_TypeError,
"TritonContext::removeCallback(): Expects a CALLBACK as first argument.");
2584 if (function ==
nullptr || !PyCallable_Check(function))
2585 return PyErr_Format(PyExc_TypeError,
"TritonContext::removeCallback(): Expects a function as second argument.");
2588 if (PyMethod_Check(function)) {
2589 cb_self = PyMethod_GET_SELF(function);
2590 cb = PyMethod_GET_FUNCTION(function);
2614 return PyErr_Format(PyExc_TypeError,
"TritonContext::removeCallback(): Invalid kind of callback.");
2621 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2625 if (cb_self !=
nullptr) {
2634 static PyObject* TritonContext_reset(PyObject* self, PyObject* noarg) {
2642 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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.");
2657 TritonContext_fillRegistersAttribute(self);
2663 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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.");
2682 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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;
2696 static char* 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");
2708 if (baseAddr ==
nullptr || (!PyLong_Check(baseAddr) && !PyInt_Check(baseAddr))) {
2709 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteMemoryAreaValue(): Expects an integer as baseAddr keyword.");
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.");
2716 if (execCallbacks !=
nullptr && !PyBool_Check(execCallbacks)) {
2717 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteMemoryAreaValue(): Expects a boolean as execCallbacks keyword.");
2720 if (execCallbacks ==
nullptr) {
2725 if (PyList_Check(values)) {
2726 for (Py_ssize_t i = 0; i < PyList_Size(values); i++) {
2727 PyObject* item = PyList_GetItem(values, i);
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.");
2742 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2747 else if (PyBytes_Check(values)) {
2758 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2763 else if (PyByteArray_Check(values)) {
2774 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2780 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteMemoryAreaValue(): Something wrong.");
2787 static PyObject* TritonContext_setConcreteMemoryValue(PyObject* self, PyObject* args, PyObject* kwargs) {
2788 PyObject* mem =
nullptr;
2789 PyObject* value =
nullptr;
2790 PyObject* execCallbacks =
nullptr;
2792 static char* 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");
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.");
2808 if (value ==
nullptr || (!PyLong_Check(value) && !PyInt_Check(value))) {
2809 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteMemoryValue(): Expects an integer as value keyword.");
2812 if (execCallbacks !=
nullptr && !PyBool_Check(execCallbacks)) {
2813 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteMemoryAreaValue(): Expects a boolean as execCallbacks keyword.");
2816 if (execCallbacks ==
nullptr) {
2821 if (PyLong_Check(mem) || PyInt_Check(mem)) {
2826 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteMemoryValue(): Value must be on 8 bits.");
2835 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2850 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2856 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteMemoryValue(): something wrong.");
2863 static PyObject* TritonContext_setConcreteRegisterValue(PyObject* self, PyObject* args, PyObject* kwargs) {
2864 PyObject* reg =
nullptr;
2865 PyObject* value =
nullptr;
2866 PyObject* execCallbacks =
nullptr;
2868 static char* keywords[] = {
2876 if (PyArg_ParseTupleAndKeywords(args, kwargs,
"OO|O", keywords, ®, &value, &execCallbacks) ==
false) {
2877 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteRegisterValue(): Invalid keyword argument");
2881 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteRegisterValue(): Expects a Register as reg keyword.");
2884 if (value ==
nullptr || (!PyLong_Check(value) && !PyInt_Check(value))) {
2885 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteRegisterValue(): Expects an integer as value keyword.");
2888 if (execCallbacks !=
nullptr && !PyBool_Check(execCallbacks)) {
2889 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteMemoryAreaValue(): Expects a boolean as execCallbacks keyword.");
2892 if (execCallbacks ==
nullptr) {
2904 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2912 static PyObject* TritonContext_setConcreteVariableValue(PyObject* self, PyObject* args) {
2913 PyObject* symVar =
nullptr;
2914 PyObject* value =
nullptr;
2917 if (PyArg_ParseTuple(args,
"|OO", &symVar, &value) ==
false) {
2918 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteVariableValue(): Invalid number of arguments");
2922 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteVariableValue(): Bad argument type.");
2924 if (value ==
nullptr)
2925 return PyErr_Format(PyExc_TypeError,
"TritonContext::setConcreteVariableValue(): Expects a second argument as integer value.");
2934 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
2942 static PyObject* TritonContext_setMode(PyObject* self, PyObject* args) {
2943 PyObject* mode =
nullptr;
2944 PyObject*
flag =
nullptr;
2947 if (PyArg_ParseTuple(args,
"|OO", &mode, &flag) ==
false) {
2948 return PyErr_Format(PyExc_TypeError,
"TritonContext::setMode(): Invalid number of arguments");
2951 if (mode ==
nullptr || (!PyLong_Check(mode) && !PyInt_Check(mode)))
2952 return PyErr_Format(PyExc_TypeError,
"TritonContext::setMode(): Expects a MODE as argument.");
2954 if (flag ==
nullptr || !PyBool_Check(flag))
2955 return PyErr_Format(PyExc_TypeError,
"TritonContext::setMode(): Expects an boolean flag as second argument.");
2964 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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.");
2980 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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.");
2996 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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.");
3012 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3020 static PyObject* TritonContext_setTaintMemory(PyObject* self, PyObject* args) {
3021 PyObject* mem =
nullptr;
3022 PyObject*
flag =
nullptr;
3025 if (PyArg_ParseTuple(args,
"|OO", &mem, &flag) ==
false) {
3026 return PyErr_Format(PyExc_TypeError,
"TritonContext::setTaintMemory(): Invalid number of arguments");
3030 return PyErr_Format(PyExc_TypeError,
"TritonContext::setTaintMemory(): Expects a MemoryAccess as first argument.");
3032 if (flag ==
nullptr || !PyBool_Check(flag))
3033 return PyErr_Format(PyExc_TypeError,
"TritonContext::setTaintMemory(): Expects a boolean as second argument.");
3044 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3049 static PyObject* TritonContext_setTaintRegister(PyObject* self, PyObject* args) {
3050 PyObject* reg =
nullptr;
3051 PyObject*
flag =
nullptr;
3054 if (PyArg_ParseTuple(args,
"|OO", ®, &flag) ==
false) {
3055 return PyErr_Format(PyExc_TypeError,
"TritonContext::setTaintRegister(): Invalid number of arguments");
3059 return PyErr_Format(PyExc_TypeError,
"TritonContext::setTaintRegister(): Expects a Register as first argument.");
3061 if (flag ==
nullptr || !PyBool_Check(flag))
3062 return PyErr_Format(PyExc_TypeError,
"TritonContext::setTaintRegister(): Expects a boolean as second argument.");
3073 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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.");
3086 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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;
3100 static char* 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");
3114 return PyErr_Format(PyExc_TypeError,
"TritonContext::simplify(): Expects a AstNode or a BasicBlock as obj argument.");
3116 if (solver !=
nullptr && !PyBool_Check(solver))
3117 return PyErr_Format(PyExc_TypeError,
"TritonContext::simplify(): Expects a boolean as solver argument.");
3119 if (llvm !=
nullptr && !PyBool_Check(llvm))
3120 return PyErr_Format(PyExc_TypeError,
"TritonContext::simplify(): Expects a boolean as llvm argument.");
3122 if (padding !=
nullptr && !PyBool_Check(padding))
3123 return PyErr_Format(PyExc_TypeError,
"TritonContext::simplify(): Expects a boolean as padding argument.");
3125 if (solver ==
nullptr)
3128 if (llvm ==
nullptr)
3131 if (padding ==
nullptr)
3142 return PyErr_Format(PyExc_TypeError,
"TritonContext::simplify(): Something wrong.");
3148 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3153 static PyObject* TritonContext_sliceExpressions(PyObject* self, PyObject* expr) {
3154 PyObject* ret =
nullptr;
3157 return PyErr_Format(PyExc_TypeError,
"TritonContext::sliceExpressions(): Expects a SymbolicExpression as argument.");
3163 for (
auto it = exprs.begin(); it != exprs.end(); it++)
3170 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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 =
"";
3184 if (PyArg_ParseTuple(args,
"|OOO", &exprId, &symVarSize, &symVarAlias) ==
false) {
3185 return PyErr_Format(PyExc_TypeError,
"TritonContext::symbolizeExpression(): Invalid number of arguments");
3188 if (exprId ==
nullptr || (!PyLong_Check(exprId) && !PyInt_Check(exprId)))
3189 return PyErr_Format(PyExc_TypeError,
"TritonContext::symbolizeExpression(): Expects an integer as first argument.");
3191 if (symVarSize ==
nullptr || (!PyLong_Check(symVarSize) && !PyInt_Check(symVarSize)))
3192 return PyErr_Format(PyExc_TypeError,
"TritonContext::symbolizeExpression(): Expects an integer as second argument.");
3194 if (symVarAlias !=
nullptr && !PyStr_Check(symVarAlias))
3195 return PyErr_Format(PyExc_TypeError,
"TritonContext::symbolizeExpression(): Expects a sting as third argument.");
3197 if (symVarAlias !=
nullptr)
3198 calias = PyStr_AsString(symVarAlias);
3207 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3212 static PyObject* TritonContext_symbolizeMemory(PyObject* self, PyObject* args) {
3213 PyObject* mem =
nullptr;
3214 PyObject* symVarAlias =
nullptr;
3215 std::string calias =
"";
3218 if (PyArg_ParseTuple(args,
"|OO", &mem, &symVarAlias) ==
false) {
3219 return PyErr_Format(PyExc_TypeError,
"TritonContext::symbolizeMemory(): Invalid number of arguments");
3223 return PyErr_Format(PyExc_TypeError,
"TritonContext::symbolizeMemory(): Expects a MemoryAccess as first argument.");
3225 if (symVarAlias !=
nullptr && !PyStr_Check(symVarAlias))
3226 return PyErr_Format(PyExc_TypeError,
"TritonContext::symbolizeMemory(): Expects a sting as second argument.");
3228 if (symVarAlias !=
nullptr)
3229 calias = PyStr_AsString(symVarAlias);
3238 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3243 static PyObject* TritonContext_symbolizeRegister(PyObject* self, PyObject* args) {
3244 PyObject* reg =
nullptr;
3245 PyObject* symVarAlias =
nullptr;
3246 std::string calias =
"";
3249 if (PyArg_ParseTuple(args,
"|OO", ®, &symVarAlias) ==
false) {
3250 return PyErr_Format(PyExc_TypeError,
"TritonContext::symbolizeRegister(): Invalid number of arguments");
3254 return PyErr_Format(PyExc_TypeError,
"TritonContext::symbolizeRegister(): Expects a Register as first argument.");
3256 if (symVarAlias !=
nullptr && !PyStr_Check(symVarAlias))
3257 return PyErr_Format(PyExc_TypeError,
"TritonContext::symbolizeRegister(): Expects a sting as second argument.");
3259 if (symVarAlias !=
nullptr)
3260 calias = PyStr_AsString(symVarAlias);
3269 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
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;
3280 static char* 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");
3294 return PyErr_Format(PyExc_TypeError,
"TritonContext::synthesize(): Expects a AstNode as node argument.");
3296 if (constant !=
nullptr && !PyBool_Check(constant))
3297 return PyErr_Format(PyExc_TypeError,
"TritonContext::synthesize(): Expects a boolean as constant argument.");
3299 if (subexpr !=
nullptr && !PyBool_Check(subexpr))
3300 return PyErr_Format(PyExc_TypeError,
"TritonContext::synthesize(): Expects a boolean as subexpr argument.");
3302 if (opaque !=
nullptr && !PyBool_Check(opaque))
3303 return PyErr_Format(PyExc_TypeError,
"TritonContext::synthesize(): Expects a boolean as opaque argument.");
3305 if (constant ==
nullptr)
3308 if (subexpr ==
nullptr)
3311 if (opaque ==
nullptr)
3316 if (result.successful()) {
3328 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3333 static PyObject* TritonContext_taintAssignment(PyObject* self, PyObject* args) {
3334 PyObject* op1 =
nullptr;
3335 PyObject* op2 =
nullptr;
3339 if (PyArg_ParseTuple(args,
"OO", &op1, &op2) ==
false) {
3340 return PyErr_Format(PyExc_TypeError,
"TritonContext::taintAssignment(): Invalid number of arguments");
3363 return PyErr_Format(PyExc_TypeError,
"TritonContext::taintAssignment(): Invalid kind of parameter.");
3374 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3379 static PyObject* TritonContext_taintMemory(PyObject* self, PyObject* mem) {
3386 else if (PyLong_Check(mem) || PyInt_Check(mem)) {
3392 return PyErr_Format(PyExc_TypeError,
"TritonContext::taintMemory(): Expects a MemoryAccess or an integer as argument.");
3398 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3404 static PyObject* TritonContext_taintRegister(PyObject* self, PyObject* reg) {
3406 return PyErr_Format(PyExc_TypeError,
"TritonContext::taintRegister(): Expects a Register as argument.");
3417 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3422 static PyObject* TritonContext_taintUnion(PyObject* self, PyObject* args) {
3423 PyObject* op1 =
nullptr;
3424 PyObject* op2 =
nullptr;
3428 if (PyArg_ParseTuple(args,
"OO", &op1, &op2) ==
false) {
3429 return PyErr_Format(PyExc_TypeError,
"TritonContext::taintUnion(): Invalid number of arguments");
3452 return PyErr_Format(PyExc_TypeError,
"TritonContext::taintUnion(): Invalid kind of parameter.");
3463 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3468 static PyObject* TritonContext_untaintMemory(PyObject* self, PyObject* mem) {
3475 else if (PyLong_Check(mem) || PyInt_Check(mem)) {
3481 return PyErr_Format(PyExc_TypeError,
"TritonContext::untaintMemory(): Expects a MemoryAccess or an integer as argument.");
3487 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3493 static PyObject* TritonContext_untaintRegister(PyObject* self, PyObject* reg) {
3495 return PyErr_Format(PyExc_TypeError,
"TritonContext::untaintRegister(): Expects a Register as argument.");
3506 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3511 static PyObject* TritonContext_getParentRegister(PyObject* self, PyObject* reg) {
3513 return PyErr_Format(PyExc_TypeError,
"TritonContext::getParentRegister(): Expects a Register as argument.");
3522 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3527 static PyObject* TritonContext_getattro(PyObject* self, PyObject* name) {
3530 if (std::string(PyStr_AsString(name)) ==
"registers") {
3534 return PyErr_Format(PyExc_TypeError,
"__getattr__.registers: Architecture is not defined.");
3537 if (((TritonContext_Object*)(self))->regAttr ==
nullptr)
3538 TritonContext_fillRegistersAttribute(self);
3540 Py_INCREF(((TritonContext_Object*)(self))->regAttr);
3541 return ((TritonContext_Object*)(self))->regAttr;
3548 return PyErr_Format(PyExc_TypeError,
"%s", e.
what());
3551 return PyObject_GenericGetAttr((PyObject *)self, name);
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}
3664 PyVarObject_HEAD_INIT(&PyType_Type, 0)
3668 (destructor)TritonContext_dealloc,
3680 (getattrofunc)TritonContext_getattro,
3684 "TritonContext objects",
3729 if (
object !=
nullptr) {
3731 object->ref =
false;
3732 object->regAttr =
nullptr;
3735 return (PyObject*)object;
3743 if (
object !=
nullptr) {
3745 object->ref =
false;
3746 object->regAttr =
nullptr;
3749 return (PyObject*)object;
3757 if (
object !=
nullptr) {
3760 object->regAttr =
nullptr;
3763 return (PyObject*)object;
This is the main Triton Context class.
This class is used to represent an instruction.
This class is used to represent a memory access.
This class is used when an instruction has a register operand.
The exception class used by callbacks.
The root class of all exceptions.
TRITON_EXPORT const char * what() const
Returns the exception message.
register_e
Types of register.
std::shared_ptr< triton::ast::AbstractNode > SharedAbstractNode
Shared Abstract Node.
constexpr triton::uint32 flag
flag size in bit
ComparableFunctor< void(triton::Context &, const triton::arch::MemoryAccess &)> getConcreteMemoryValueCallback
The prototype of a GET_CONCRETE_MEMORY_VALUE callback.
ComparableFunctor< void(triton::Context &, const triton::arch::Register &, const triton::uint512 &value)> setConcreteRegisterValueCallback
The prototype of a SET_CONCRETE_REGISTER_VALUE callback.
ComparableFunctor< triton::ast::SharedAbstractNode(triton::Context &, const triton::ast::SharedAbstractNode &)> symbolicSimplificationCallback
The prototype of a SYMBOLIC_SIMPLIFICATION callback.
ComparableFunctor< void(triton::Context &, const triton::arch::MemoryAccess &, const triton::uint512 &value)> setConcreteMemoryValueCallback
The prototype of a SET_CONCRETE_MEMORY_VALUE callback.
ComparableFunctor< void(triton::Context &, const triton::arch::Register &)> getConcreteRegisterValueCallback
The prototype of a GET_CONCRETE_REGISTER_VALUE callback.
@ SYMBOLIC_SIMPLIFICATION
@ GET_CONCRETE_REGISTER_VALUE
@ GET_CONCRETE_MEMORY_VALUE
@ SET_CONCRETE_MEMORY_VALUE
@ SET_CONCRETE_REGISTER_VALUE
mode_e
Enumerates all kinds of mode.
PyObject * PyTritonContextRef(triton::Context &ctx)
Creates a TritonContext python class which is a reference to another Context.
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...
PyObject * PyPathConstraint(const triton::engines::symbolic::PathConstraint &pc)
Creates the PathConstraint python class.
PyObject * PySymbolicVariable(const triton::engines::symbolic::SharedSymbolicVariable &symVar)
Creates the SymbolicVariable python class.
PyObject * PySolverModel(const triton::engines::solver::SolverModel &model)
Creates the SolverModel python class.
triton::uint64 PyLong_AsUint64(PyObject *vv)
Returns a triton::uint64 from a pyObject.
PyObject * PyLong_FromUsize(triton::usize value)
Returns a pyObject from a triton::usize.
PyObject * xPyTuple_New(Py_ssize_t len)
Creates a PyTuple and raises an exception if it fails.
PyObject * xPyString_FromString(const char *v)
Creates a PyString and raises an exception if it fails.
bool PyLong_AsBool(PyObject *obj)
Returns a bool from a pyObject.
PyObject * PyLong_FromUint512(triton::uint512 value)
Returns a pyObject from a triton::uint512.
triton::uint512 PyLong_AsUint512(PyObject *vv)
Returns a triton::uint512 from a pyObject.
PyObject * PyAstContext(const triton::ast::SharedAstContext &actx)
Creates an AstContext python class.
PyObject * PyBasicBlock(void)
Creates the BasicBlock python class.
PyObject * PyInstruction(void)
Creates the Instruction python class.
PyObject * xPyList_New(Py_ssize_t len)
Creates a PyList and raises an exception if it fails.
int xPyDict_SetItem(PyObject *p, PyObject *key, PyObject *val)
Same as PyDict_SetItem but decrements reference on object and key.
PyObject * PyLong_FromUint64(triton::uint64 value)
Returns a pyObject from a triton::uint64.
PyObject * PyRegister(const triton::arch::Register ®)
Creates the Register python class.
PyObject * PyTritonContext(void)
Creates the new TritonContext python class.
triton::uint32 PyLong_AsUint32(PyObject *vv)
Returns a triton::uint32 from a pyObject.
triton::usize PyLong_AsUsize(PyObject *vv)
Returns a triton::usize from a pyObject.
PyObject * PySymbolicExpression(const triton::engines::symbolic::SharedSymbolicExpression &symExpr)
Creates the SymbolicExpression python class.
PyObject * PyMemoryAccess(const triton::arch::MemoryAccess &mem)
Creates the Memory python class.
PyObject * xPyDict_New(void)
Creates a PyDict and raises an exception if it fails.
PyObject * PyLong_FromUint32(triton::uint32 value)
Returns a pyObject from a triton::uint32.
PyObject * PyAstNode(const triton::ast::SharedAbstractNode &node)
Creates the AstNode python class.
mode_e
All types of representation mode.
std::shared_ptr< triton::engines::symbolic::SymbolicExpression > SharedSymbolicExpression
Shared Symbolic Expression.
std::size_t usize
unsigned MAX_INT 32 or 64 bits according to the CPU.
std::uint64_t uint64
unisgned 64-bits
std::uint32_t uint32
unisgned 32-bits
std::uint8_t uint8
unisgned 8-bits
PyTypeObject TritonContext_Type
Description of the python representation of a TritonContext.
PyMethodDef TritonContext_callbacks[]
TritonContext methods.
#define PySymbolicVariable_Check(v)
#define PyImmediate_Check(v)
#define PyRegister_AsRegister(v)
#define PyMemoryAccess_Check(v)
#define PyTritonContext_AsTritonContext(v)
#define PyInstruction_AsInstruction(v)
#define PyImmediate_AsImmediate(v)
#define PyInstruction_Check(v)
#define PyAstNode_Check(v)
#define PyMemoryAccess_AsMemoryAccess(v)
#define PyBasicBlock_AsBasicBlock(v)
#define PyRegister_Check(v)
#define PyBasicBlock_Check(v)
#define PySymbolicExpression_Check(v)
#define PySymbolicVariable_AsSymbolicVariable(v)
#define PyAstNode_AsAstNode(v)
#define PySymbolicExpression_AsSymbolicExpression(v)