partition stringclasses 3
values | func_name stringlengths 1 134 | docstring stringlengths 1 46.9k | path stringlengths 4 223 | original_string stringlengths 75 104k | code stringlengths 75 104k | docstring_tokens listlengths 1 1.97k | repo stringlengths 7 55 | language stringclasses 1
value | url stringlengths 87 315 | code_tokens listlengths 19 28.4k | sha stringlengths 40 40 |
|---|---|---|---|---|---|---|---|---|---|---|---|
valid | Memory._ceil | Returns the smallest page boundary value not less than the address.
:rtype: int
:param address: the address to calculate its ceil.
:return: the ceil of C{address}. | manticore/native/memory.py | def _ceil(self, address):
"""
Returns the smallest page boundary value not less than the address.
:rtype: int
:param address: the address to calculate its ceil.
:return: the ceil of C{address}.
"""
return (((address - 1) + self.page_size) & ~self.page_mask) & self... | def _ceil(self, address):
"""
Returns the smallest page boundary value not less than the address.
:rtype: int
:param address: the address to calculate its ceil.
:return: the ceil of C{address}.
"""
return (((address - 1) + self.page_size) & ~self.page_mask) & self... | [
"Returns",
"the",
"smallest",
"page",
"boundary",
"value",
"not",
"less",
"than",
"the",
"address",
".",
":",
"rtype",
":",
"int",
":",
"param",
"address",
":",
"the",
"address",
"to",
"calculate",
"its",
"ceil",
".",
":",
"return",
":",
"the",
"ceil",
... | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L550-L557 | [
"def",
"_ceil",
"(",
"self",
",",
"address",
")",
":",
"return",
"(",
"(",
"(",
"address",
"-",
"1",
")",
"+",
"self",
".",
"page_size",
")",
"&",
"~",
"self",
".",
"page_mask",
")",
"&",
"self",
".",
"memory_mask"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Memory._search | Recursively searches the address space for enough free space to allocate C{size} bytes.
:param size: the size in bytes to allocate.
:param start: an address from where to start the search.
:param counter: internal parameter to know if all the memory was already scanned.
:return: the add... | manticore/native/memory.py | def _search(self, size, start=None, counter=0):
"""
Recursively searches the address space for enough free space to allocate C{size} bytes.
:param size: the size in bytes to allocate.
:param start: an address from where to start the search.
:param counter: internal parameter to ... | def _search(self, size, start=None, counter=0):
"""
Recursively searches the address space for enough free space to allocate C{size} bytes.
:param size: the size in bytes to allocate.
:param start: an address from where to start the search.
:param counter: internal parameter to ... | [
"Recursively",
"searches",
"the",
"address",
"space",
"for",
"enough",
"free",
"space",
"to",
"allocate",
"C",
"{",
"size",
"}",
"bytes",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L579-L614 | [
"def",
"_search",
"(",
"self",
",",
"size",
",",
"start",
"=",
"None",
",",
"counter",
"=",
"0",
")",
":",
"assert",
"size",
"&",
"self",
".",
"page_mask",
"==",
"0",
"if",
"start",
"is",
"None",
":",
"end",
"=",
"{",
"32",
":",
"0xf8000000",
","... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Memory.mmapFile | Creates a new file mapping in the memory address space.
:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough
chunk of memory will be selected as starting address.
:param size: the contents of a file mapping are initialized using C{size} bytes st... | manticore/native/memory.py | def mmapFile(self, addr, size, perms, filename, offset=0):
"""
Creates a new file mapping in the memory address space.
:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough
chunk of memory will be selected as starting address.
:pa... | def mmapFile(self, addr, size, perms, filename, offset=0):
"""
Creates a new file mapping in the memory address space.
:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough
chunk of memory will be selected as starting address.
:pa... | [
"Creates",
"a",
"new",
"file",
"mapping",
"in",
"the",
"memory",
"address",
"space",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L616-L664 | [
"def",
"mmapFile",
"(",
"self",
",",
"addr",
",",
"size",
",",
"perms",
",",
"filename",
",",
"offset",
"=",
"0",
")",
":",
"# If addr is NULL, the system determines where to allocate the region.",
"assert",
"addr",
"is",
"None",
"or",
"isinstance",
"(",
"addr",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Memory.mmap | Creates a new mapping in the memory address space.
:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough
chunk of memory will be selected as starting address.
:param size: the length of the mapping.
:param perms: the access permissions to... | manticore/native/memory.py | def mmap(self, addr, size, perms, data_init=None, name=None):
"""
Creates a new mapping in the memory address space.
:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough
chunk of memory will be selected as starting address.
:para... | def mmap(self, addr, size, perms, data_init=None, name=None):
"""
Creates a new mapping in the memory address space.
:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough
chunk of memory will be selected as starting address.
:para... | [
"Creates",
"a",
"new",
"mapping",
"in",
"the",
"memory",
"address",
"space",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L666-L713 | [
"def",
"mmap",
"(",
"self",
",",
"addr",
",",
"size",
",",
"perms",
",",
"data_init",
"=",
"None",
",",
"name",
"=",
"None",
")",
":",
"# If addr is NULL, the system determines where to allocate the region.",
"assert",
"addr",
"is",
"None",
"or",
"isinstance",
"... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Memory.map_containing | Returns the L{MMap} object containing the address.
:param address: the address to obtain its mapping.
:rtype: L{MMap}
@todo: symbolic address | manticore/native/memory.py | def map_containing(self, address):
"""
Returns the L{MMap} object containing the address.
:param address: the address to obtain its mapping.
:rtype: L{MMap}
@todo: symbolic address
"""
page_offset = self._page(address)
if page_offset not in self._page2ma... | def map_containing(self, address):
"""
Returns the L{MMap} object containing the address.
:param address: the address to obtain its mapping.
:rtype: L{MMap}
@todo: symbolic address
"""
page_offset = self._page(address)
if page_offset not in self._page2ma... | [
"Returns",
"the",
"L",
"{",
"MMap",
"}",
"object",
"containing",
"the",
"address",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L734-L746 | [
"def",
"map_containing",
"(",
"self",
",",
"address",
")",
":",
"page_offset",
"=",
"self",
".",
"_page",
"(",
"address",
")",
"if",
"page_offset",
"not",
"in",
"self",
".",
"_page2map",
":",
"raise",
"MemoryException",
"(",
"\"Page not mapped\"",
",",
"addr... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Memory.mappings | Returns a sorted list of all the mappings for this memory.
:return: a list of mappings.
:rtype: list | manticore/native/memory.py | def mappings(self):
"""
Returns a sorted list of all the mappings for this memory.
:return: a list of mappings.
:rtype: list
"""
result = []
for m in self.maps:
if isinstance(m, AnonMap):
result.append((m.start, m.end, m.perms, 0, ''))... | def mappings(self):
"""
Returns a sorted list of all the mappings for this memory.
:return: a list of mappings.
:rtype: list
"""
result = []
for m in self.maps:
if isinstance(m, AnonMap):
result.append((m.start, m.end, m.perms, 0, ''))... | [
"Returns",
"a",
"sorted",
"list",
"of",
"all",
"the",
"mappings",
"for",
"this",
"memory",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L748-L764 | [
"def",
"mappings",
"(",
"self",
")",
":",
"result",
"=",
"[",
"]",
"for",
"m",
"in",
"self",
".",
"maps",
":",
"if",
"isinstance",
"(",
"m",
",",
"AnonMap",
")",
":",
"result",
".",
"append",
"(",
"(",
"m",
".",
"start",
",",
"m",
".",
"end",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Memory._maps_in_range | Generates the list of maps that overlaps with the range [start:end] | manticore/native/memory.py | def _maps_in_range(self, start, end):
"""
Generates the list of maps that overlaps with the range [start:end]
"""
# Search for the first matching map
addr = start
while addr < end:
if addr not in self:
addr += self.page_size
else:
... | def _maps_in_range(self, start, end):
"""
Generates the list of maps that overlaps with the range [start:end]
"""
# Search for the first matching map
addr = start
while addr < end:
if addr not in self:
addr += self.page_size
else:
... | [
"Generates",
"the",
"list",
"of",
"maps",
"that",
"overlaps",
"with",
"the",
"range",
"[",
"start",
":",
"end",
"]"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L769-L782 | [
"def",
"_maps_in_range",
"(",
"self",
",",
"start",
",",
"end",
")",
":",
"# Search for the first matching map",
"addr",
"=",
"start",
"while",
"addr",
"<",
"end",
":",
"if",
"addr",
"not",
"in",
"self",
":",
"addr",
"+=",
"self",
".",
"page_size",
"else",... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Memory.munmap | Deletes the mappings for the specified address range and causes further
references to addresses within the range to generate invalid memory
references.
:param start: the starting address to delete.
:param size: the length of the unmapping. | manticore/native/memory.py | def munmap(self, start, size):
"""
Deletes the mappings for the specified address range and causes further
references to addresses within the range to generate invalid memory
references.
:param start: the starting address to delete.
:param size: the length of the unmappi... | def munmap(self, start, size):
"""
Deletes the mappings for the specified address range and causes further
references to addresses within the range to generate invalid memory
references.
:param start: the starting address to delete.
:param size: the length of the unmappi... | [
"Deletes",
"the",
"mappings",
"for",
"the",
"specified",
"address",
"range",
"and",
"causes",
"further",
"references",
"to",
"addresses",
"within",
"the",
"range",
"to",
"generate",
"invalid",
"memory",
"references",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L784-L809 | [
"def",
"munmap",
"(",
"self",
",",
"start",
",",
"size",
")",
":",
"start",
"=",
"self",
".",
"_floor",
"(",
"start",
")",
"end",
"=",
"self",
".",
"_ceil",
"(",
"start",
"+",
"size",
")",
"self",
".",
"cpu",
".",
"_publish",
"(",
"'will_unmap_memo... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Memory.pop_record_writes | Stop recording trace and return a `list[(address, value)]` of all the writes
that occurred, where `value` is of type list[str]. Can be called without
intermediate `pop_record_writes()`.
For example::
mem.push_record_writes()
mem.write(1, 'a')
mem.pus... | manticore/native/memory.py | def pop_record_writes(self):
"""
Stop recording trace and return a `list[(address, value)]` of all the writes
that occurred, where `value` is of type list[str]. Can be called without
intermediate `pop_record_writes()`.
For example::
mem.push_record_writes()
... | def pop_record_writes(self):
"""
Stop recording trace and return a `list[(address, value)]` of all the writes
that occurred, where `value` is of type list[str]. Can be called without
intermediate `pop_record_writes()`.
For example::
mem.push_record_writes()
... | [
"Stop",
"recording",
"trace",
"and",
"return",
"a",
"list",
"[",
"(",
"address",
"value",
")",
"]",
"of",
"all",
"the",
"writes",
"that",
"occurred",
"where",
"value",
"is",
"of",
"type",
"list",
"[",
"str",
"]",
".",
"Can",
"be",
"called",
"without",
... | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L894-L919 | [
"def",
"pop_record_writes",
"(",
"self",
")",
":",
"lst",
"=",
"self",
".",
"_recording_stack",
".",
"pop",
"(",
")",
"# Append the current list to a previously-started trace.",
"if",
"self",
".",
"_recording_stack",
":",
"self",
".",
"_recording_stack",
"[",
"-",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | SMemory.munmap | Deletes the mappings for the specified address range and causes further
references to addresses within the range to generate invalid memory
references.
:param start: the starting address to delete.
:param size: the length of the unmapping. | manticore/native/memory.py | def munmap(self, start, size):
"""
Deletes the mappings for the specified address range and causes further
references to addresses within the range to generate invalid memory
references.
:param start: the starting address to delete.
:param size: the length of the unmappi... | def munmap(self, start, size):
"""
Deletes the mappings for the specified address range and causes further
references to addresses within the range to generate invalid memory
references.
:param start: the starting address to delete.
:param size: the length of the unmappi... | [
"Deletes",
"the",
"mappings",
"for",
"the",
"specified",
"address",
"range",
"and",
"causes",
"further",
"references",
"to",
"addresses",
"within",
"the",
"range",
"to",
"generate",
"invalid",
"memory",
"references",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L1010-L1024 | [
"def",
"munmap",
"(",
"self",
",",
"start",
",",
"size",
")",
":",
"for",
"addr",
"in",
"range",
"(",
"start",
",",
"start",
"+",
"size",
")",
":",
"if",
"len",
"(",
"self",
".",
"_symbols",
")",
"==",
"0",
":",
"break",
"if",
"addr",
"in",
"se... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | SMemory.read | Read a stream of potentially symbolic bytes from a potentially symbolic
address
:param address: Where to read from
:param size: How many bytes
:param force: Whether to ignore permissions
:rtype: list | manticore/native/memory.py | def read(self, address, size, force=False):
"""
Read a stream of potentially symbolic bytes from a potentially symbolic
address
:param address: Where to read from
:param size: How many bytes
:param force: Whether to ignore permissions
:rtype: list
"""
... | def read(self, address, size, force=False):
"""
Read a stream of potentially symbolic bytes from a potentially symbolic
address
:param address: Where to read from
:param size: How many bytes
:param force: Whether to ignore permissions
:rtype: list
"""
... | [
"Read",
"a",
"stream",
"of",
"potentially",
"symbolic",
"bytes",
"from",
"a",
"potentially",
"symbolic",
"address"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L1026-L1098 | [
"def",
"read",
"(",
"self",
",",
"address",
",",
"size",
",",
"force",
"=",
"False",
")",
":",
"size",
"=",
"self",
".",
"_get_size",
"(",
"size",
")",
"assert",
"not",
"issymbolic",
"(",
"size",
")",
"if",
"issymbolic",
"(",
"address",
")",
":",
"... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | SMemory.write | Write a value at address.
:param address: The address at which to write
:type address: int or long or Expression
:param value: Bytes to write
:type value: str or list
:param force: Whether to ignore permissions | manticore/native/memory.py | def write(self, address, value, force=False):
"""
Write a value at address.
:param address: The address at which to write
:type address: int or long or Expression
:param value: Bytes to write
:type value: str or list
:param force: Whether to ignore permissions
... | def write(self, address, value, force=False):
"""
Write a value at address.
:param address: The address at which to write
:type address: int or long or Expression
:param value: Bytes to write
:type value: str or list
:param force: Whether to ignore permissions
... | [
"Write",
"a",
"value",
"at",
"address",
".",
":",
"param",
"address",
":",
"The",
"address",
"at",
"which",
"to",
"write",
":",
"type",
"address",
":",
"int",
"or",
"long",
"or",
"Expression",
":",
"param",
"value",
":",
"Bytes",
"to",
"write",
":",
... | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L1100-L1129 | [
"def",
"write",
"(",
"self",
",",
"address",
",",
"value",
",",
"force",
"=",
"False",
")",
":",
"size",
"=",
"len",
"(",
"value",
")",
"if",
"issymbolic",
"(",
"address",
")",
":",
"solutions",
"=",
"self",
".",
"_try_get_solutions",
"(",
"address",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | SMemory._try_get_solutions | Try to solve for a symbolic address, checking permissions when reading/writing size bytes.
:param Expression address: The address to solve for
:param int size: How many bytes to check permissions for
:param str access: 'r' or 'w'
:param int max_solutions: Will raise if more solutions ar... | manticore/native/memory.py | def _try_get_solutions(self, address, size, access, max_solutions=0x1000, force=False):
"""
Try to solve for a symbolic address, checking permissions when reading/writing size bytes.
:param Expression address: The address to solve for
:param int size: How many bytes to check permissions... | def _try_get_solutions(self, address, size, access, max_solutions=0x1000, force=False):
"""
Try to solve for a symbolic address, checking permissions when reading/writing size bytes.
:param Expression address: The address to solve for
:param int size: How many bytes to check permissions... | [
"Try",
"to",
"solve",
"for",
"a",
"symbolic",
"address",
"checking",
"permissions",
"when",
"reading",
"/",
"writing",
"size",
"bytes",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L1131-L1154 | [
"def",
"_try_get_solutions",
"(",
"self",
",",
"address",
",",
"size",
",",
"access",
",",
"max_solutions",
"=",
"0x1000",
",",
"force",
"=",
"False",
")",
":",
"assert",
"issymbolic",
"(",
"address",
")",
"solutions",
"=",
"solver",
".",
"get_all_values",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | LazySMemory.mmapFile | Creates a new file mapping in the memory address space.
:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough
chunk of memory will be selected as starting address.
:param size: the contents of a file mapping are initialized using C{size} bytes st... | manticore/native/memory.py | def mmapFile(self, addr, size, perms, filename, offset=0):
"""
Creates a new file mapping in the memory address space.
:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough
chunk of memory will be selected as starting address.
:pa... | def mmapFile(self, addr, size, perms, filename, offset=0):
"""
Creates a new file mapping in the memory address space.
:param addr: the starting address (took as hint). If C{addr} is C{0} the first big enough
chunk of memory will be selected as starting address.
:pa... | [
"Creates",
"a",
"new",
"file",
"mapping",
"in",
"the",
"memory",
"address",
"space",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L1179-L1228 | [
"def",
"mmapFile",
"(",
"self",
",",
"addr",
",",
"size",
",",
"perms",
",",
"filename",
",",
"offset",
"=",
"0",
")",
":",
"# If addr is NULL, the system determines where to allocate the region.",
"assert",
"addr",
"is",
"None",
"or",
"isinstance",
"(",
"addr",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | LazySMemory._import_concrete_memory | for each address in this range need to read from concrete and write to symbolic
it's possible that there will be invalid/unmapped addresses in this range. need to skip to next map if so
also need to mark all of these addresses as now in the symbolic store
:param int from_addr:
:param in... | manticore/native/memory.py | def _import_concrete_memory(self, from_addr, to_addr):
"""
for each address in this range need to read from concrete and write to symbolic
it's possible that there will be invalid/unmapped addresses in this range. need to skip to next map if so
also need to mark all of these addresses as... | def _import_concrete_memory(self, from_addr, to_addr):
"""
for each address in this range need to read from concrete and write to symbolic
it's possible that there will be invalid/unmapped addresses in this range. need to skip to next map if so
also need to mark all of these addresses as... | [
"for",
"each",
"address",
"in",
"this",
"range",
"need",
"to",
"read",
"from",
"concrete",
"and",
"write",
"to",
"symbolic",
"it",
"s",
"possible",
"that",
"there",
"will",
"be",
"invalid",
"/",
"unmapped",
"addresses",
"in",
"this",
"range",
".",
"need",
... | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L1237-L1261 | [
"def",
"_import_concrete_memory",
"(",
"self",
",",
"from_addr",
",",
"to_addr",
")",
":",
"logger",
".",
"debug",
"(",
"\"Importing concrete memory: {:x} - {:x} ({} bytes)\"",
".",
"format",
"(",
"from_addr",
",",
"to_addr",
",",
"to_addr",
"-",
"from_addr",
")",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | LazySMemory.scan_mem | Scan for concrete bytes in all mapped memory. Successively yield addresses of all matches.
:param bytes data_to_find: String to locate
:return: | manticore/native/memory.py | def scan_mem(self, data_to_find):
"""
Scan for concrete bytes in all mapped memory. Successively yield addresses of all matches.
:param bytes data_to_find: String to locate
:return:
"""
# TODO: for the moment we just treat symbolic bytes as bytes that don't match.
... | def scan_mem(self, data_to_find):
"""
Scan for concrete bytes in all mapped memory. Successively yield addresses of all matches.
:param bytes data_to_find: String to locate
:return:
"""
# TODO: for the moment we just treat symbolic bytes as bytes that don't match.
... | [
"Scan",
"for",
"concrete",
"bytes",
"in",
"all",
"mapped",
"memory",
".",
"Successively",
"yield",
"addresses",
"of",
"all",
"matches",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/memory.py#L1332-L1363 | [
"def",
"scan_mem",
"(",
"self",
",",
"data_to_find",
")",
":",
"# TODO: for the moment we just treat symbolic bytes as bytes that don't match.",
"# for our simple test cases right now, the bytes we're interested in scanning",
"# for will all just be there concretely",
"# TODO: Can probably do ... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Operand._reg_name | Translates a register ID from the disassembler object into the
register name based on manticore's alias in the register file
:param int reg_id: Register ID | manticore/native/cpu/abstractcpu.py | def _reg_name(self, reg_id):
"""
Translates a register ID from the disassembler object into the
register name based on manticore's alias in the register file
:param int reg_id: Register ID
"""
if reg_id >= X86_REG_ENDING:
logger.warning("Trying to get registe... | def _reg_name(self, reg_id):
"""
Translates a register ID from the disassembler object into the
register name based on manticore's alias in the register file
:param int reg_id: Register ID
"""
if reg_id >= X86_REG_ENDING:
logger.warning("Trying to get registe... | [
"Translates",
"a",
"register",
"ID",
"from",
"the",
"disassembler",
"object",
"into",
"the",
"register",
"name",
"based",
"on",
"manticore",
"s",
"alias",
"in",
"the",
"register",
"file"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L142-L155 | [
"def",
"_reg_name",
"(",
"self",
",",
"reg_id",
")",
":",
"if",
"reg_id",
">=",
"X86_REG_ENDING",
":",
"logger",
".",
"warning",
"(",
"\"Trying to get register name for a non-register\"",
")",
"return",
"None",
"cs_reg_name",
"=",
"self",
".",
"cpu",
".",
"instr... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Abi.values_from | A reusable generator for increasing pointer-sized values from an address
(usually the stack). | manticore/native/cpu/abstractcpu.py | def values_from(self, base):
"""
A reusable generator for increasing pointer-sized values from an address
(usually the stack).
"""
word_bytes = self._cpu.address_bit_size // 8
while True:
yield base
base += word_bytes | def values_from(self, base):
"""
A reusable generator for increasing pointer-sized values from an address
(usually the stack).
"""
word_bytes = self._cpu.address_bit_size // 8
while True:
yield base
base += word_bytes | [
"A",
"reusable",
"generator",
"for",
"increasing",
"pointer",
"-",
"sized",
"values",
"from",
"an",
"address",
"(",
"usually",
"the",
"stack",
")",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L291-L299 | [
"def",
"values_from",
"(",
"self",
",",
"base",
")",
":",
"word_bytes",
"=",
"self",
".",
"_cpu",
".",
"address_bit_size",
"//",
"8",
"while",
"True",
":",
"yield",
"base",
"base",
"+=",
"word_bytes"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Abi.get_argument_values | Extract arguments for model from the environment and return as a tuple that
is ready to be passed to the model.
:param callable model: Python model of the function
:param tuple prefix_args: Parameters to pass to model before actual ones
:return: Arguments to be passed to the model
... | manticore/native/cpu/abstractcpu.py | def get_argument_values(self, model, prefix_args):
"""
Extract arguments for model from the environment and return as a tuple that
is ready to be passed to the model.
:param callable model: Python model of the function
:param tuple prefix_args: Parameters to pass to model before... | def get_argument_values(self, model, prefix_args):
"""
Extract arguments for model from the environment and return as a tuple that
is ready to be passed to the model.
:param callable model: Python model of the function
:param tuple prefix_args: Parameters to pass to model before... | [
"Extract",
"arguments",
"for",
"model",
"from",
"the",
"environment",
"and",
"return",
"as",
"a",
"tuple",
"that",
"is",
"ready",
"to",
"be",
"passed",
"to",
"the",
"model",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L301-L339 | [
"def",
"get_argument_values",
"(",
"self",
",",
"model",
",",
"prefix_args",
")",
":",
"spec",
"=",
"inspect",
".",
"getfullargspec",
"(",
"model",
")",
"if",
"spec",
".",
"varargs",
":",
"logger",
".",
"warning",
"(",
"\"ABI: A vararg model must be a unary func... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Abi.invoke | Invoke a callable `model` as if it was a native function. If
:func:`~manticore.models.isvariadic` returns true for `model`, `model` receives a single
argument that is a generator for function arguments. Pass a tuple of
arguments for `prefix_args` you'd like to precede the actual
argument... | manticore/native/cpu/abstractcpu.py | def invoke(self, model, prefix_args=None):
"""
Invoke a callable `model` as if it was a native function. If
:func:`~manticore.models.isvariadic` returns true for `model`, `model` receives a single
argument that is a generator for function arguments. Pass a tuple of
arguments for ... | def invoke(self, model, prefix_args=None):
"""
Invoke a callable `model` as if it was a native function. If
:func:`~manticore.models.isvariadic` returns true for `model`, `model` receives a single
argument that is a generator for function arguments. Pass a tuple of
arguments for ... | [
"Invoke",
"a",
"callable",
"model",
"as",
"if",
"it",
"was",
"a",
"native",
"function",
".",
"If",
":",
"func",
":",
"~manticore",
".",
"models",
".",
"isvariadic",
"returns",
"true",
"for",
"model",
"model",
"receives",
"a",
"single",
"argument",
"that",
... | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L341-L378 | [
"def",
"invoke",
"(",
"self",
",",
"model",
",",
"prefix_args",
"=",
"None",
")",
":",
"prefix_args",
"=",
"prefix_args",
"or",
"(",
")",
"arguments",
"=",
"self",
".",
"get_argument_values",
"(",
"model",
",",
"prefix_args",
")",
"try",
":",
"result",
"... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.write_register | Dynamic interface for writing cpu registers
:param str register: register name (as listed in `self.all_registers`)
:param value: register value
:type value: int or long or Expression | manticore/native/cpu/abstractcpu.py | def write_register(self, register, value):
"""
Dynamic interface for writing cpu registers
:param str register: register name (as listed in `self.all_registers`)
:param value: register value
:type value: int or long or Expression
"""
self._publish('will_write_reg... | def write_register(self, register, value):
"""
Dynamic interface for writing cpu registers
:param str register: register name (as listed in `self.all_registers`)
:param value: register value
:type value: int or long or Expression
"""
self._publish('will_write_reg... | [
"Dynamic",
"interface",
"for",
"writing",
"cpu",
"registers"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L530-L541 | [
"def",
"write_register",
"(",
"self",
",",
"register",
",",
"value",
")",
":",
"self",
".",
"_publish",
"(",
"'will_write_register'",
",",
"register",
",",
"value",
")",
"value",
"=",
"self",
".",
"_regfile",
".",
"write",
"(",
"register",
",",
"value",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.read_register | Dynamic interface for reading cpu registers
:param str register: register name (as listed in `self.all_registers`)
:return: register value
:rtype: int or long or Expression | manticore/native/cpu/abstractcpu.py | def read_register(self, register):
"""
Dynamic interface for reading cpu registers
:param str register: register name (as listed in `self.all_registers`)
:return: register value
:rtype: int or long or Expression
"""
self._publish('will_read_register', register)
... | def read_register(self, register):
"""
Dynamic interface for reading cpu registers
:param str register: register name (as listed in `self.all_registers`)
:return: register value
:rtype: int or long or Expression
"""
self._publish('will_read_register', register)
... | [
"Dynamic",
"interface",
"for",
"reading",
"cpu",
"registers"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L543-L554 | [
"def",
"read_register",
"(",
"self",
",",
"register",
")",
":",
"self",
".",
"_publish",
"(",
"'will_read_register'",
",",
"register",
")",
"value",
"=",
"self",
".",
"_regfile",
".",
"read",
"(",
"register",
")",
"self",
".",
"_publish",
"(",
"'did_read_r... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.emulate_until | Tells the CPU to set up a concrete unicorn emulator and use it to execute instructions
until target is reached.
:param target: Where Unicorn should hand control back to Manticore. Set to 0 for all instructions. | manticore/native/cpu/abstractcpu.py | def emulate_until(self, target: int):
"""
Tells the CPU to set up a concrete unicorn emulator and use it to execute instructions
until target is reached.
:param target: Where Unicorn should hand control back to Manticore. Set to 0 for all instructions.
"""
self._concrete... | def emulate_until(self, target: int):
"""
Tells the CPU to set up a concrete unicorn emulator and use it to execute instructions
until target is reached.
:param target: Where Unicorn should hand control back to Manticore. Set to 0 for all instructions.
"""
self._concrete... | [
"Tells",
"the",
"CPU",
"to",
"set",
"up",
"a",
"concrete",
"unicorn",
"emulator",
"and",
"use",
"it",
"to",
"execute",
"instructions",
"until",
"target",
"is",
"reached",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L583-L593 | [
"def",
"emulate_until",
"(",
"self",
",",
"target",
":",
"int",
")",
":",
"self",
".",
"_concrete",
"=",
"True",
"self",
".",
"_break_unicorn_at",
"=",
"target",
"if",
"self",
".",
"emu",
":",
"self",
".",
"emu",
".",
"_stop_at",
"=",
"target"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.write_int | Writes int to memory
:param int where: address to write to
:param expr: value to write
:type expr: int or BitVec
:param size: bit size of `expr`
:param force: whether to ignore memory permissions | manticore/native/cpu/abstractcpu.py | def write_int(self, where, expression, size=None, force=False):
"""
Writes int to memory
:param int where: address to write to
:param expr: value to write
:type expr: int or BitVec
:param size: bit size of `expr`
:param force: whether to ignore memory permissions... | def write_int(self, where, expression, size=None, force=False):
"""
Writes int to memory
:param int where: address to write to
:param expr: value to write
:type expr: int or BitVec
:param size: bit size of `expr`
:param force: whether to ignore memory permissions... | [
"Writes",
"int",
"to",
"memory"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L601-L619 | [
"def",
"write_int",
"(",
"self",
",",
"where",
",",
"expression",
",",
"size",
"=",
"None",
",",
"force",
"=",
"False",
")",
":",
"if",
"size",
"is",
"None",
":",
"size",
"=",
"self",
".",
"address_bit_size",
"assert",
"size",
"in",
"SANE_SIZES",
"self... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu._raw_read | Selects bytes from memory. Attempts to do so faster than via read_bytes.
:param where: address to read from
:param size: number of bytes to read
:return: the bytes in memory | manticore/native/cpu/abstractcpu.py | def _raw_read(self, where: int, size=1) -> bytes:
"""
Selects bytes from memory. Attempts to do so faster than via read_bytes.
:param where: address to read from
:param size: number of bytes to read
:return: the bytes in memory
"""
map = self.memory.map_containin... | def _raw_read(self, where: int, size=1) -> bytes:
"""
Selects bytes from memory. Attempts to do so faster than via read_bytes.
:param where: address to read from
:param size: number of bytes to read
:return: the bytes in memory
"""
map = self.memory.map_containin... | [
"Selects",
"bytes",
"from",
"memory",
".",
"Attempts",
"to",
"do",
"so",
"faster",
"than",
"via",
"read_bytes",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L621-L653 | [
"def",
"_raw_read",
"(",
"self",
",",
"where",
":",
"int",
",",
"size",
"=",
"1",
")",
"->",
"bytes",
":",
"map",
"=",
"self",
".",
"memory",
".",
"map_containing",
"(",
"where",
")",
"start",
"=",
"map",
".",
"_get_offset",
"(",
"where",
")",
"map... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.read_int | Reads int from memory
:param int where: address to read from
:param size: number of bits to read
:return: the value read
:rtype: int or BitVec
:param force: whether to ignore memory permissions | manticore/native/cpu/abstractcpu.py | def read_int(self, where, size=None, force=False):
"""
Reads int from memory
:param int where: address to read from
:param size: number of bits to read
:return: the value read
:rtype: int or BitVec
:param force: whether to ignore memory permissions
"""
... | def read_int(self, where, size=None, force=False):
"""
Reads int from memory
:param int where: address to read from
:param size: number of bits to read
:return: the value read
:rtype: int or BitVec
:param force: whether to ignore memory permissions
"""
... | [
"Reads",
"int",
"from",
"memory"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L655-L675 | [
"def",
"read_int",
"(",
"self",
",",
"where",
",",
"size",
"=",
"None",
",",
"force",
"=",
"False",
")",
":",
"if",
"size",
"is",
"None",
":",
"size",
"=",
"self",
".",
"address_bit_size",
"assert",
"size",
"in",
"SANE_SIZES",
"self",
".",
"_publish",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.write_bytes | Write a concrete or symbolic (or mixed) buffer to memory
:param int where: address to write to
:param data: data to write
:type data: str or list
:param force: whether to ignore memory permissions | manticore/native/cpu/abstractcpu.py | def write_bytes(self, where, data, force=False):
"""
Write a concrete or symbolic (or mixed) buffer to memory
:param int where: address to write to
:param data: data to write
:type data: str or list
:param force: whether to ignore memory permissions
"""
... | def write_bytes(self, where, data, force=False):
"""
Write a concrete or symbolic (or mixed) buffer to memory
:param int where: address to write to
:param data: data to write
:type data: str or list
:param force: whether to ignore memory permissions
"""
... | [
"Write",
"a",
"concrete",
"or",
"symbolic",
"(",
"or",
"mixed",
")",
"buffer",
"to",
"memory"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L677-L707 | [
"def",
"write_bytes",
"(",
"self",
",",
"where",
",",
"data",
",",
"force",
"=",
"False",
")",
":",
"mp",
"=",
"self",
".",
"memory",
".",
"map_containing",
"(",
"where",
")",
"# TODO (ehennenfent) - fast write can have some yet-unstudied unintended side effects.",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.read_bytes | Read from memory.
:param int where: address to read data from
:param int size: number of bytes
:param force: whether to ignore memory permissions
:return: data
:rtype: list[int or Expression] | manticore/native/cpu/abstractcpu.py | def read_bytes(self, where, size, force=False):
"""
Read from memory.
:param int where: address to read data from
:param int size: number of bytes
:param force: whether to ignore memory permissions
:return: data
:rtype: list[int or Expression]
"""
... | def read_bytes(self, where, size, force=False):
"""
Read from memory.
:param int where: address to read data from
:param int size: number of bytes
:param force: whether to ignore memory permissions
:return: data
:rtype: list[int or Expression]
"""
... | [
"Read",
"from",
"memory",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L709-L722 | [
"def",
"read_bytes",
"(",
"self",
",",
"where",
",",
"size",
",",
"force",
"=",
"False",
")",
":",
"result",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"size",
")",
":",
"result",
".",
"append",
"(",
"Operators",
".",
"CHR",
"(",
"self",
".",... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.write_string | Writes a string to memory, appending a NULL-terminator at the end.
:param int where: Address to write the string to
:param str string: The string to write to memory
:param int max_length:
The size in bytes to cap the string at, or None [default] for no
limit. This include... | manticore/native/cpu/abstractcpu.py | def write_string(self, where, string, max_length=None, force=False):
"""
Writes a string to memory, appending a NULL-terminator at the end.
:param int where: Address to write the string to
:param str string: The string to write to memory
:param int max_length:
The siz... | def write_string(self, where, string, max_length=None, force=False):
"""
Writes a string to memory, appending a NULL-terminator at the end.
:param int where: Address to write the string to
:param str string: The string to write to memory
:param int max_length:
The siz... | [
"Writes",
"a",
"string",
"to",
"memory",
"appending",
"a",
"NULL",
"-",
"terminator",
"at",
"the",
"end",
".",
":",
"param",
"int",
"where",
":",
"Address",
"to",
"write",
"the",
"string",
"to",
":",
"param",
"str",
"string",
":",
"The",
"string",
"to"... | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L724-L738 | [
"def",
"write_string",
"(",
"self",
",",
"where",
",",
"string",
",",
"max_length",
"=",
"None",
",",
"force",
"=",
"False",
")",
":",
"if",
"max_length",
"is",
"not",
"None",
":",
"string",
"=",
"string",
"[",
":",
"max_length",
"-",
"1",
"]",
"self... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.read_string | Read a NUL-terminated concrete buffer from memory. Stops reading at first symbolic byte.
:param int where: Address to read string from
:param int max_length:
The size in bytes to cap the string at, or None [default] for no
limit.
:param force: whether to ignore memory pe... | manticore/native/cpu/abstractcpu.py | def read_string(self, where, max_length=None, force=False):
"""
Read a NUL-terminated concrete buffer from memory. Stops reading at first symbolic byte.
:param int where: Address to read string from
:param int max_length:
The size in bytes to cap the string at, or None [defa... | def read_string(self, where, max_length=None, force=False):
"""
Read a NUL-terminated concrete buffer from memory. Stops reading at first symbolic byte.
:param int where: Address to read string from
:param int max_length:
The size in bytes to cap the string at, or None [defa... | [
"Read",
"a",
"NUL",
"-",
"terminated",
"concrete",
"buffer",
"from",
"memory",
".",
"Stops",
"reading",
"at",
"first",
"symbolic",
"byte",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L740-L765 | [
"def",
"read_string",
"(",
"self",
",",
"where",
",",
"max_length",
"=",
"None",
",",
"force",
"=",
"False",
")",
":",
"s",
"=",
"io",
".",
"BytesIO",
"(",
")",
"while",
"True",
":",
"c",
"=",
"self",
".",
"read_int",
"(",
"where",
",",
"8",
",",... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.push_bytes | Write `data` to the stack and decrement the stack pointer accordingly.
:param str data: Data to write
:param force: whether to ignore memory permissions | manticore/native/cpu/abstractcpu.py | def push_bytes(self, data, force=False):
"""
Write `data` to the stack and decrement the stack pointer accordingly.
:param str data: Data to write
:param force: whether to ignore memory permissions
"""
self.STACK -= len(data)
self.write_bytes(self.STACK, data, fo... | def push_bytes(self, data, force=False):
"""
Write `data` to the stack and decrement the stack pointer accordingly.
:param str data: Data to write
:param force: whether to ignore memory permissions
"""
self.STACK -= len(data)
self.write_bytes(self.STACK, data, fo... | [
"Write",
"data",
"to",
"the",
"stack",
"and",
"decrement",
"the",
"stack",
"pointer",
"accordingly",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L767-L776 | [
"def",
"push_bytes",
"(",
"self",
",",
"data",
",",
"force",
"=",
"False",
")",
":",
"self",
".",
"STACK",
"-=",
"len",
"(",
"data",
")",
"self",
".",
"write_bytes",
"(",
"self",
".",
"STACK",
",",
"data",
",",
"force",
")",
"return",
"self",
".",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.pop_bytes | Read `nbytes` from the stack, increment the stack pointer, and return
data.
:param int nbytes: How many bytes to read
:param force: whether to ignore memory permissions
:return: Data read from the stack | manticore/native/cpu/abstractcpu.py | def pop_bytes(self, nbytes, force=False):
"""
Read `nbytes` from the stack, increment the stack pointer, and return
data.
:param int nbytes: How many bytes to read
:param force: whether to ignore memory permissions
:return: Data read from the stack
"""
da... | def pop_bytes(self, nbytes, force=False):
"""
Read `nbytes` from the stack, increment the stack pointer, and return
data.
:param int nbytes: How many bytes to read
:param force: whether to ignore memory permissions
:return: Data read from the stack
"""
da... | [
"Read",
"nbytes",
"from",
"the",
"stack",
"increment",
"the",
"stack",
"pointer",
"and",
"return",
"data",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L778-L789 | [
"def",
"pop_bytes",
"(",
"self",
",",
"nbytes",
",",
"force",
"=",
"False",
")",
":",
"data",
"=",
"self",
".",
"read_bytes",
"(",
"self",
".",
"STACK",
",",
"nbytes",
",",
"force",
"=",
"force",
")",
"self",
".",
"STACK",
"+=",
"nbytes",
"return",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.push_int | Decrement the stack pointer and write `value` to the stack.
:param int value: The value to write
:param force: whether to ignore memory permissions
:return: New stack pointer | manticore/native/cpu/abstractcpu.py | def push_int(self, value, force=False):
"""
Decrement the stack pointer and write `value` to the stack.
:param int value: The value to write
:param force: whether to ignore memory permissions
:return: New stack pointer
"""
self.STACK -= self.address_bit_size // 8... | def push_int(self, value, force=False):
"""
Decrement the stack pointer and write `value` to the stack.
:param int value: The value to write
:param force: whether to ignore memory permissions
:return: New stack pointer
"""
self.STACK -= self.address_bit_size // 8... | [
"Decrement",
"the",
"stack",
"pointer",
"and",
"write",
"value",
"to",
"the",
"stack",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L791-L801 | [
"def",
"push_int",
"(",
"self",
",",
"value",
",",
"force",
"=",
"False",
")",
":",
"self",
".",
"STACK",
"-=",
"self",
".",
"address_bit_size",
"//",
"8",
"self",
".",
"write_int",
"(",
"self",
".",
"STACK",
",",
"value",
",",
"force",
"=",
"force",... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.pop_int | Read a value from the stack and increment the stack pointer.
:param force: whether to ignore memory permissions
:return: Value read | manticore/native/cpu/abstractcpu.py | def pop_int(self, force=False):
"""
Read a value from the stack and increment the stack pointer.
:param force: whether to ignore memory permissions
:return: Value read
"""
value = self.read_int(self.STACK, force=force)
self.STACK += self.address_bit_size // 8
... | def pop_int(self, force=False):
"""
Read a value from the stack and increment the stack pointer.
:param force: whether to ignore memory permissions
:return: Value read
"""
value = self.read_int(self.STACK, force=force)
self.STACK += self.address_bit_size // 8
... | [
"Read",
"a",
"value",
"from",
"the",
"stack",
"and",
"increment",
"the",
"stack",
"pointer",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L803-L812 | [
"def",
"pop_int",
"(",
"self",
",",
"force",
"=",
"False",
")",
":",
"value",
"=",
"self",
".",
"read_int",
"(",
"self",
".",
"STACK",
",",
"force",
"=",
"force",
")",
"self",
".",
"STACK",
"+=",
"self",
".",
"address_bit_size",
"//",
"8",
"return",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.decode_instruction | This will decode an instruction from memory pointed by `pc`
:param int pc: address of the instruction | manticore/native/cpu/abstractcpu.py | def decode_instruction(self, pc):
"""
This will decode an instruction from memory pointed by `pc`
:param int pc: address of the instruction
"""
# No dynamic code!!! #TODO!
# Check if instruction was already decoded
if pc in self._instruction_cache:
re... | def decode_instruction(self, pc):
"""
This will decode an instruction from memory pointed by `pc`
:param int pc: address of the instruction
"""
# No dynamic code!!! #TODO!
# Check if instruction was already decoded
if pc in self._instruction_cache:
re... | [
"This",
"will",
"decode",
"an",
"instruction",
"from",
"memory",
"pointed",
"by",
"pc"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L824-L880 | [
"def",
"decode_instruction",
"(",
"self",
",",
"pc",
")",
":",
"# No dynamic code!!! #TODO!",
"# Check if instruction was already decoded",
"if",
"pc",
"in",
"self",
".",
"_instruction_cache",
":",
"return",
"self",
".",
"_instruction_cache",
"[",
"pc",
"]",
"text",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.execute | Decode, and execute one instruction pointed by register PC | manticore/native/cpu/abstractcpu.py | def execute(self):
"""
Decode, and execute one instruction pointed by register PC
"""
if issymbolic(self.PC):
raise ConcretizeRegister(self, 'PC', policy='ALL')
if not self.memory.access_ok(self.PC, 'x'):
raise InvalidMemoryAccess(self.PC, 'x')
s... | def execute(self):
"""
Decode, and execute one instruction pointed by register PC
"""
if issymbolic(self.PC):
raise ConcretizeRegister(self, 'PC', policy='ALL')
if not self.memory.access_ok(self.PC, 'x'):
raise InvalidMemoryAccess(self.PC, 'x')
s... | [
"Decode",
"and",
"execute",
"one",
"instruction",
"pointed",
"by",
"register",
"PC"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L897-L949 | [
"def",
"execute",
"(",
"self",
")",
":",
"if",
"issymbolic",
"(",
"self",
".",
"PC",
")",
":",
"raise",
"ConcretizeRegister",
"(",
"self",
",",
"'PC'",
",",
"policy",
"=",
"'ALL'",
")",
"if",
"not",
"self",
".",
"memory",
".",
"access_ok",
"(",
"self... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu._publish_instruction_as_executed | Notify listeners that an instruction has been executed. | manticore/native/cpu/abstractcpu.py | def _publish_instruction_as_executed(self, insn):
"""
Notify listeners that an instruction has been executed.
"""
self._icount += 1
self._publish('did_execute_instruction', self._last_pc, self.PC, insn) | def _publish_instruction_as_executed(self, insn):
"""
Notify listeners that an instruction has been executed.
"""
self._icount += 1
self._publish('did_execute_instruction', self._last_pc, self.PC, insn) | [
"Notify",
"listeners",
"that",
"an",
"instruction",
"has",
"been",
"executed",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L954-L959 | [
"def",
"_publish_instruction_as_executed",
"(",
"self",
",",
"insn",
")",
":",
"self",
".",
"_icount",
"+=",
"1",
"self",
".",
"_publish",
"(",
"'did_execute_instruction'",
",",
"self",
".",
"_last_pc",
",",
"self",
".",
"PC",
",",
"insn",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.emulate | Pick the right emulate function (maintains API compatiblity)
:param insn: single instruction to emulate/start emulation from | manticore/native/cpu/abstractcpu.py | def emulate(self, insn):
"""
Pick the right emulate function (maintains API compatiblity)
:param insn: single instruction to emulate/start emulation from
"""
if self._concrete:
self.concrete_emulate(insn)
else:
self.backup_emulate(insn) | def emulate(self, insn):
"""
Pick the right emulate function (maintains API compatiblity)
:param insn: single instruction to emulate/start emulation from
"""
if self._concrete:
self.concrete_emulate(insn)
else:
self.backup_emulate(insn) | [
"Pick",
"the",
"right",
"emulate",
"function",
"(",
"maintains",
"API",
"compatiblity",
")"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L961-L971 | [
"def",
"emulate",
"(",
"self",
",",
"insn",
")",
":",
"if",
"self",
".",
"_concrete",
":",
"self",
".",
"concrete_emulate",
"(",
"insn",
")",
"else",
":",
"self",
".",
"backup_emulate",
"(",
"insn",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.concrete_emulate | Start executing in Unicorn from this point until we hit a syscall or reach break_unicorn_at
:param capstone.CsInsn insn: The instruction object to emulate | manticore/native/cpu/abstractcpu.py | def concrete_emulate(self, insn):
"""
Start executing in Unicorn from this point until we hit a syscall or reach break_unicorn_at
:param capstone.CsInsn insn: The instruction object to emulate
"""
if not self.emu:
self.emu = ConcreteUnicornEmulator(self)
... | def concrete_emulate(self, insn):
"""
Start executing in Unicorn from this point until we hit a syscall or reach break_unicorn_at
:param capstone.CsInsn insn: The instruction object to emulate
"""
if not self.emu:
self.emu = ConcreteUnicornEmulator(self)
... | [
"Start",
"executing",
"in",
"Unicorn",
"from",
"this",
"point",
"until",
"we",
"hit",
"a",
"syscall",
"or",
"reach",
"break_unicorn_at"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L973-L990 | [
"def",
"concrete_emulate",
"(",
"self",
",",
"insn",
")",
":",
"if",
"not",
"self",
".",
"emu",
":",
"self",
".",
"emu",
"=",
"ConcreteUnicornEmulator",
"(",
"self",
")",
"self",
".",
"emu",
".",
"_stop_at",
"=",
"self",
".",
"_break_unicorn_at",
"try",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | Cpu.backup_emulate | If we could not handle emulating an instruction, use Unicorn to emulate
it.
:param capstone.CsInsn instruction: The instruction object to emulate | manticore/native/cpu/abstractcpu.py | def backup_emulate(self, insn):
"""
If we could not handle emulating an instruction, use Unicorn to emulate
it.
:param capstone.CsInsn instruction: The instruction object to emulate
"""
if not hasattr(self, 'backup_emu'):
self.backup_emu = UnicornEmulator(se... | def backup_emulate(self, insn):
"""
If we could not handle emulating an instruction, use Unicorn to emulate
it.
:param capstone.CsInsn instruction: The instruction object to emulate
"""
if not hasattr(self, 'backup_emu'):
self.backup_emu = UnicornEmulator(se... | [
"If",
"we",
"could",
"not",
"handle",
"emulating",
"an",
"instruction",
"use",
"Unicorn",
"to",
"emulate",
"it",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/abstractcpu.py#L992-L1014 | [
"def",
"backup_emulate",
"(",
"self",
",",
"insn",
")",
":",
"if",
"not",
"hasattr",
"(",
"self",
",",
"'backup_emu'",
")",
":",
"self",
".",
"backup_emu",
"=",
"UnicornEmulator",
"(",
"self",
")",
"try",
":",
"self",
".",
"backup_emu",
".",
"emulate",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | viz_trace | Given a Manticore trace file, highlight the basic blocks. | scripts/binaryninja/manticore_viz/__init__.py | def viz_trace(view):
"""
Given a Manticore trace file, highlight the basic blocks.
"""
tv = TraceVisualizer(view, None)
if tv.workspace is None:
tv.workspace = get_workspace()
tv.visualize() | def viz_trace(view):
"""
Given a Manticore trace file, highlight the basic blocks.
"""
tv = TraceVisualizer(view, None)
if tv.workspace is None:
tv.workspace = get_workspace()
tv.visualize() | [
"Given",
"a",
"Manticore",
"trace",
"file",
"highlight",
"the",
"basic",
"blocks",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/scripts/binaryninja/manticore_viz/__init__.py#L166-L173 | [
"def",
"viz_trace",
"(",
"view",
")",
":",
"tv",
"=",
"TraceVisualizer",
"(",
"view",
",",
"None",
")",
"if",
"tv",
".",
"workspace",
"is",
"None",
":",
"tv",
".",
"workspace",
"=",
"get_workspace",
"(",
")",
"tv",
".",
"visualize",
"(",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | viz_live_trace | Given a Manticore trace file, highlight the basic blocks. | scripts/binaryninja/manticore_viz/__init__.py | def viz_live_trace(view):
"""
Given a Manticore trace file, highlight the basic blocks.
"""
tv = TraceVisualizer(view, None, live=True)
if tv.workspace is None:
tv.workspace = get_workspace()
# update due to singleton in case we are called after a clear
tv.live_update = True
tv.v... | def viz_live_trace(view):
"""
Given a Manticore trace file, highlight the basic blocks.
"""
tv = TraceVisualizer(view, None, live=True)
if tv.workspace is None:
tv.workspace = get_workspace()
# update due to singleton in case we are called after a clear
tv.live_update = True
tv.v... | [
"Given",
"a",
"Manticore",
"trace",
"file",
"highlight",
"the",
"basic",
"blocks",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/scripts/binaryninja/manticore_viz/__init__.py#L175-L184 | [
"def",
"viz_live_trace",
"(",
"view",
")",
":",
"tv",
"=",
"TraceVisualizer",
"(",
"view",
",",
"None",
",",
"live",
"=",
"True",
")",
"if",
"tv",
".",
"workspace",
"is",
"None",
":",
"tv",
".",
"workspace",
"=",
"get_workspace",
"(",
")",
"# update du... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | TraceVisualizer.visualize | Given a Manticore workspace, or trace file, highlight the basic blocks. | scripts/binaryninja/manticore_viz/__init__.py | def visualize(self):
"""
Given a Manticore workspace, or trace file, highlight the basic blocks.
"""
if os.path.isfile(self.workspace):
t = threading.Thread(target=self.highlight_from_file,
args=(self.workspace,))
elif os.path.isdir(se... | def visualize(self):
"""
Given a Manticore workspace, or trace file, highlight the basic blocks.
"""
if os.path.isfile(self.workspace):
t = threading.Thread(target=self.highlight_from_file,
args=(self.workspace,))
elif os.path.isdir(se... | [
"Given",
"a",
"Manticore",
"workspace",
"or",
"trace",
"file",
"highlight",
"the",
"basic",
"blocks",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/scripts/binaryninja/manticore_viz/__init__.py#L43-L53 | [
"def",
"visualize",
"(",
"self",
")",
":",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"self",
".",
"workspace",
")",
":",
"t",
"=",
"threading",
".",
"Thread",
"(",
"target",
"=",
"self",
".",
"highlight_from_file",
",",
"args",
"=",
"(",
"self",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | t_TOKEN | [a-zA-Z0-9]+ | manticore/core/parser/parser.py | def t_TOKEN(t):
'[a-zA-Z0-9]+'
#print t.value,t.lexer.lexdata[t.lexer.lexpos-len(t.value):],re_TYPE.match(t.lexer.lexdata,t.lexer.lexpos-len(t.value))
if re_TYPE.match(t.value):
t.type = 'TYPE'
elif re_PTR.match(t.value):
t.type = 'PTR'
elif re_NUMBER.match(t.value):
if t.val... | def t_TOKEN(t):
'[a-zA-Z0-9]+'
#print t.value,t.lexer.lexdata[t.lexer.lexpos-len(t.value):],re_TYPE.match(t.lexer.lexdata,t.lexer.lexpos-len(t.value))
if re_TYPE.match(t.value):
t.type = 'TYPE'
elif re_PTR.match(t.value):
t.type = 'PTR'
elif re_NUMBER.match(t.value):
if t.val... | [
"[",
"a",
"-",
"zA",
"-",
"Z0",
"-",
"9",
"]",
"+"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/core/parser/parser.py#L85-L103 | [
"def",
"t_TOKEN",
"(",
"t",
")",
":",
"#print t.value,t.lexer.lexdata[t.lexer.lexpos-len(t.value):],re_TYPE.match(t.lexer.lexdata,t.lexer.lexpos-len(t.value))",
"if",
"re_TYPE",
".",
"match",
"(",
"t",
".",
"value",
")",
":",
"t",
".",
"type",
"=",
"'TYPE'",
"elif",
"re... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | p_expression_deref | expression : TYPE PTR LBRAKET expression RBRAKET | manticore/core/parser/parser.py | def p_expression_deref(p):
'expression : TYPE PTR LBRAKET expression RBRAKET'
size = sizes[p[1]]
address = p[4]
char_list = functions['read_memory'](address, size)
value = Operators.CONCAT(8 * len(char_list), *reversed(map(Operators.ORD, char_list)))
p[0] = value | def p_expression_deref(p):
'expression : TYPE PTR LBRAKET expression RBRAKET'
size = sizes[p[1]]
address = p[4]
char_list = functions['read_memory'](address, size)
value = Operators.CONCAT(8 * len(char_list), *reversed(map(Operators.ORD, char_list)))
p[0] = value | [
"expression",
":",
"TYPE",
"PTR",
"LBRAKET",
"expression",
"RBRAKET"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/core/parser/parser.py#L213-L219 | [
"def",
"p_expression_deref",
"(",
"p",
")",
":",
"size",
"=",
"sizes",
"[",
"p",
"[",
"1",
"]",
"]",
"address",
"=",
"p",
"[",
"4",
"]",
"char_list",
"=",
"functions",
"[",
"'read_memory'",
"]",
"(",
"address",
",",
"size",
")",
"value",
"=",
"Oper... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | p_expression_derefseg | expression : TYPE PTR SEGMENT COLOM LBRAKET expression RBRAKET | manticore/core/parser/parser.py | def p_expression_derefseg(p):
'expression : TYPE PTR SEGMENT COLOM LBRAKET expression RBRAKET'
size = sizes[p[1]]
address = p[6]
seg = functions['read_register'](p[3])
base, limit, _ = functions['get_descriptor'](seg)
address = base + address
char_list = functions['read_memory'](address, siz... | def p_expression_derefseg(p):
'expression : TYPE PTR SEGMENT COLOM LBRAKET expression RBRAKET'
size = sizes[p[1]]
address = p[6]
seg = functions['read_register'](p[3])
base, limit, _ = functions['get_descriptor'](seg)
address = base + address
char_list = functions['read_memory'](address, siz... | [
"expression",
":",
"TYPE",
"PTR",
"SEGMENT",
"COLOM",
"LBRAKET",
"expression",
"RBRAKET"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/core/parser/parser.py#L222-L231 | [
"def",
"p_expression_derefseg",
"(",
"p",
")",
":",
"size",
"=",
"sizes",
"[",
"p",
"[",
"1",
"]",
"]",
"address",
"=",
"p",
"[",
"6",
"]",
"seg",
"=",
"functions",
"[",
"'read_register'",
"]",
"(",
"p",
"[",
"3",
"]",
")",
"base",
",",
"limit",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | AMD64RegFile._get_flags | Build EFLAGS/RFLAGS from flags | manticore/native/cpu/x86.py | def _get_flags(self, reg):
""" Build EFLAGS/RFLAGS from flags """
def make_symbolic(flag_expr):
register_size = 32 if reg == 'EFLAGS' else 64
value, offset = flag_expr
return Operators.ITEBV(register_size, value,
BitVecConstant(regis... | def _get_flags(self, reg):
""" Build EFLAGS/RFLAGS from flags """
def make_symbolic(flag_expr):
register_size = 32 if reg == 'EFLAGS' else 64
value, offset = flag_expr
return Operators.ITEBV(register_size, value,
BitVecConstant(regis... | [
"Build",
"EFLAGS",
"/",
"RFLAGS",
"from",
"flags"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L529-L548 | [
"def",
"_get_flags",
"(",
"self",
",",
"reg",
")",
":",
"def",
"make_symbolic",
"(",
"flag_expr",
")",
":",
"register_size",
"=",
"32",
"if",
"reg",
"==",
"'EFLAGS'",
"else",
"64",
"value",
",",
"offset",
"=",
"flag_expr",
"return",
"Operators",
".",
"IT... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | AMD64RegFile._set_flags | Set individual flags from a EFLAGS/RFLAGS value | manticore/native/cpu/x86.py | def _set_flags(self, reg, res):
""" Set individual flags from a EFLAGS/RFLAGS value """
#assert sizeof (res) == 32 if reg == 'EFLAGS' else 64
for flag, offset in self._flags.items():
self.write(flag, Operators.EXTRACT(res, offset, 1)) | def _set_flags(self, reg, res):
""" Set individual flags from a EFLAGS/RFLAGS value """
#assert sizeof (res) == 32 if reg == 'EFLAGS' else 64
for flag, offset in self._flags.items():
self.write(flag, Operators.EXTRACT(res, offset, 1)) | [
"Set",
"individual",
"flags",
"from",
"a",
"EFLAGS",
"/",
"RFLAGS",
"value"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L550-L554 | [
"def",
"_set_flags",
"(",
"self",
",",
"reg",
",",
"res",
")",
":",
"#assert sizeof (res) == 32 if reg == 'EFLAGS' else 64",
"for",
"flag",
",",
"offset",
"in",
"self",
".",
"_flags",
".",
"items",
"(",
")",
":",
"self",
".",
"write",
"(",
"flag",
",",
"Op... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.push | Writes a value in the stack.
:param value: the value to put in the stack.
:param size: the size of the value. | manticore/native/cpu/x86.py | def push(cpu, value, size):
"""
Writes a value in the stack.
:param value: the value to put in the stack.
:param size: the size of the value.
"""
assert size in (8, 16, cpu.address_bit_size)
cpu.STACK = cpu.STACK - size // 8
base, _, _ = cpu.get_descripto... | def push(cpu, value, size):
"""
Writes a value in the stack.
:param value: the value to put in the stack.
:param size: the size of the value.
"""
assert size in (8, 16, cpu.address_bit_size)
cpu.STACK = cpu.STACK - size // 8
base, _, _ = cpu.get_descripto... | [
"Writes",
"a",
"value",
"in",
"the",
"stack",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L729-L740 | [
"def",
"push",
"(",
"cpu",
",",
"value",
",",
"size",
")",
":",
"assert",
"size",
"in",
"(",
"8",
",",
"16",
",",
"cpu",
".",
"address_bit_size",
")",
"cpu",
".",
"STACK",
"=",
"cpu",
".",
"STACK",
"-",
"size",
"//",
"8",
"base",
",",
"_",
",",... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.pop | Gets a value from the stack.
:rtype: int
:param size: the size of the value to consume from the stack.
:return: the value from the stack. | manticore/native/cpu/x86.py | def pop(cpu, size):
"""
Gets a value from the stack.
:rtype: int
:param size: the size of the value to consume from the stack.
:return: the value from the stack.
"""
assert size in (16, cpu.address_bit_size)
base, _, _ = cpu.get_descriptor(cpu.SS)
... | def pop(cpu, size):
"""
Gets a value from the stack.
:rtype: int
:param size: the size of the value to consume from the stack.
:return: the value from the stack.
"""
assert size in (16, cpu.address_bit_size)
base, _, _ = cpu.get_descriptor(cpu.SS)
... | [
"Gets",
"a",
"value",
"from",
"the",
"stack",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L742-L755 | [
"def",
"pop",
"(",
"cpu",
",",
"size",
")",
":",
"assert",
"size",
"in",
"(",
"16",
",",
"cpu",
".",
"address_bit_size",
")",
"base",
",",
"_",
",",
"_",
"=",
"cpu",
".",
"get_descriptor",
"(",
"cpu",
".",
"SS",
")",
"address",
"=",
"cpu",
".",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.invalidate_cache | remove decoded instruction from instruction cache | manticore/native/cpu/x86.py | def invalidate_cache(cpu, address, size):
""" remove decoded instruction from instruction cache """
cache = cpu.instruction_cache
for offset in range(size):
if address + offset in cache:
del cache[address + offset] | def invalidate_cache(cpu, address, size):
""" remove decoded instruction from instruction cache """
cache = cpu.instruction_cache
for offset in range(size):
if address + offset in cache:
del cache[address + offset] | [
"remove",
"decoded",
"instruction",
"from",
"instruction",
"cache"
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L761-L766 | [
"def",
"invalidate_cache",
"(",
"cpu",
",",
"address",
",",
"size",
")",
":",
"cache",
"=",
"cpu",
".",
"instruction_cache",
"for",
"offset",
"in",
"range",
"(",
"size",
")",
":",
"if",
"address",
"+",
"offset",
"in",
"cache",
":",
"del",
"cache",
"[",... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CPUID | CPUID instruction.
The ID flag (bit 21) in the EFLAGS register indicates support for the
CPUID instruction. If a software procedure can set and clear this
flag, the processor executing the procedure supports the CPUID
instruction. This instruction operates the same in non-64-bit modes ... | manticore/native/cpu/x86.py | def CPUID(cpu):
"""
CPUID instruction.
The ID flag (bit 21) in the EFLAGS register indicates support for the
CPUID instruction. If a software procedure can set and clear this
flag, the processor executing the procedure supports the CPUID
instruction. This instruction op... | def CPUID(cpu):
"""
CPUID instruction.
The ID flag (bit 21) in the EFLAGS register indicates support for the
CPUID instruction. If a software procedure can set and clear this
flag, the processor executing the procedure supports the CPUID
instruction. This instruction op... | [
"CPUID",
"instruction",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L809-L855 | [
"def",
"CPUID",
"(",
"cpu",
")",
":",
"# FIXME Choose conservative values and consider returning some default when eax not here",
"conf",
"=",
"{",
"0x0",
":",
"(",
"0x0000000d",
",",
"0x756e6547",
",",
"0x6c65746e",
",",
"0x49656e69",
")",
",",
"0x1",
":",
"(",
"0x... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.AND | Logical AND.
Performs a bitwise AND operation on the destination (first) and source
(second) operands and stores the result in the destination operand location.
Each bit of the result is set to 1 if both corresponding bits of the first and
second operands are 1; otherwise, it is set to ... | manticore/native/cpu/x86.py | def AND(cpu, dest, src):
"""
Logical AND.
Performs a bitwise AND operation on the destination (first) and source
(second) operands and stores the result in the destination operand location.
Each bit of the result is set to 1 if both corresponding bits of the first and
se... | def AND(cpu, dest, src):
"""
Logical AND.
Performs a bitwise AND operation on the destination (first) and source
(second) operands and stores the result in the destination operand location.
Each bit of the result is set to 1 if both corresponding bits of the first and
se... | [
"Logical",
"AND",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L877-L902 | [
"def",
"AND",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"# XXX bypass a capstone bug that incorrectly extends and computes operands sizes",
"# the bug has been fixed since capstone 4.0.alpha2 (commit de8dd26)",
"if",
"src",
".",
"size",
"==",
"64",
"and",
"src",
".",
"... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.TEST | Logical compare.
Computes the bit-wise logical AND of first operand (source 1 operand)
and the second operand (source 2 operand) and sets the SF, ZF, and PF
status flags according to the result. The result is then discarded::
TEMP = SRC1 AND SRC2;
SF = MSB(TEMP);
... | manticore/native/cpu/x86.py | def TEST(cpu, src1, src2):
"""
Logical compare.
Computes the bit-wise logical AND of first operand (source 1 operand)
and the second operand (source 2 operand) and sets the SF, ZF, and PF
status flags according to the result. The result is then discarded::
TEMP = ... | def TEST(cpu, src1, src2):
"""
Logical compare.
Computes the bit-wise logical AND of first operand (source 1 operand)
and the second operand (source 2 operand) and sets the SF, ZF, and PF
status flags according to the result. The result is then discarded::
TEMP = ... | [
"Logical",
"compare",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L905-L934 | [
"def",
"TEST",
"(",
"cpu",
",",
"src1",
",",
"src2",
")",
":",
"# Defined Flags: szp",
"temp",
"=",
"src1",
".",
"read",
"(",
")",
"&",
"src2",
".",
"read",
"(",
")",
"cpu",
".",
"SF",
"=",
"(",
"temp",
"&",
"(",
"1",
"<<",
"(",
"src1",
".",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.XOR | Logical exclusive OR.
Performs a bitwise exclusive Operators.OR(XOR) operation on the destination (first)
and source (second) operands and stores the result in the destination
operand location.
Each bit of the result is 1 if the corresponding bits of the operands
are different;... | manticore/native/cpu/x86.py | def XOR(cpu, dest, src):
"""
Logical exclusive OR.
Performs a bitwise exclusive Operators.OR(XOR) operation on the destination (first)
and source (second) operands and stores the result in the destination
operand location.
Each bit of the result is 1 if the correspondin... | def XOR(cpu, dest, src):
"""
Logical exclusive OR.
Performs a bitwise exclusive Operators.OR(XOR) operation on the destination (first)
and source (second) operands and stores the result in the destination
operand location.
Each bit of the result is 1 if the correspondin... | [
"Logical",
"exclusive",
"OR",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L954-L979 | [
"def",
"XOR",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"if",
"dest",
"==",
"src",
":",
"# if the operands are the same write zero",
"res",
"=",
"dest",
".",
"write",
"(",
"0",
")",
"else",
":",
"res",
"=",
"dest",
".",
"write",
"(",
"dest",
"."... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.OR | Logical inclusive OR.
Performs a bitwise inclusive OR operation between the destination (first)
and source (second) operands and stores the result in the destination operand location.
Each bit of the result of the OR instruction is set to 0 if both corresponding
bits of the first and s... | manticore/native/cpu/x86.py | def OR(cpu, dest, src):
"""
Logical inclusive OR.
Performs a bitwise inclusive OR operation between the destination (first)
and source (second) operands and stores the result in the destination operand location.
Each bit of the result of the OR instruction is set to 0 if both c... | def OR(cpu, dest, src):
"""
Logical inclusive OR.
Performs a bitwise inclusive OR operation between the destination (first)
and source (second) operands and stores the result in the destination operand location.
Each bit of the result of the OR instruction is set to 0 if both c... | [
"Logical",
"inclusive",
"OR",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L982-L1003 | [
"def",
"OR",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"res",
"=",
"dest",
".",
"write",
"(",
"dest",
".",
"read",
"(",
")",
"|",
"src",
".",
"read",
"(",
")",
")",
"# Defined Flags: szp",
"cpu",
".",
"_calculate_logic_flags",
"(",
"dest",
"."... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.AAA | ASCII adjust after addition.
Adjusts the sum of two unpacked BCD values to create an unpacked BCD
result. The AL register is the implied source and destination operand
for this instruction. The AAA instruction is only useful when it follows
an ADD instruction that adds (binary addition)... | manticore/native/cpu/x86.py | def AAA(cpu):
"""
ASCII adjust after addition.
Adjusts the sum of two unpacked BCD values to create an unpacked BCD
result. The AL register is the implied source and destination operand
for this instruction. The AAA instruction is only useful when it follows
an ADD instr... | def AAA(cpu):
"""
ASCII adjust after addition.
Adjusts the sum of two unpacked BCD values to create an unpacked BCD
result. The AL register is the implied source and destination operand
for this instruction. The AAA instruction is only useful when it follows
an ADD instr... | [
"ASCII",
"adjust",
"after",
"addition",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1013-L1059 | [
"def",
"AAA",
"(",
"cpu",
")",
":",
"cpu",
".",
"AF",
"=",
"Operators",
".",
"OR",
"(",
"cpu",
".",
"AL",
"&",
"0x0F",
">",
"9",
",",
"cpu",
".",
"AF",
")",
"cpu",
".",
"CF",
"=",
"cpu",
".",
"AF",
"cpu",
".",
"AH",
"=",
"Operators",
".",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.AAD | ASCII adjust AX before division.
Adjusts two unpacked BCD digits (the least-significant digit in the
AL register and the most-significant digit in the AH register) so that
a division operation performed on the result will yield a correct unpacked
BCD value. The AAD instruction is only u... | manticore/native/cpu/x86.py | def AAD(cpu, imm=None):
"""
ASCII adjust AX before division.
Adjusts two unpacked BCD digits (the least-significant digit in the
AL register and the most-significant digit in the AH register) so that
a division operation performed on the result will yield a correct unpacked
... | def AAD(cpu, imm=None):
"""
ASCII adjust AX before division.
Adjusts two unpacked BCD digits (the least-significant digit in the
AL register and the most-significant digit in the AH register) so that
a division operation performed on the result will yield a correct unpacked
... | [
"ASCII",
"adjust",
"AX",
"before",
"division",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1062-L1097 | [
"def",
"AAD",
"(",
"cpu",
",",
"imm",
"=",
"None",
")",
":",
"if",
"imm",
"is",
"None",
":",
"imm",
"=",
"10",
"else",
":",
"imm",
"=",
"imm",
".",
"read",
"(",
")",
"cpu",
".",
"AL",
"+=",
"cpu",
".",
"AH",
"*",
"imm",
"cpu",
".",
"AH",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.AAM | ASCII adjust AX after multiply.
Adjusts the result of the multiplication of two unpacked BCD values
to create a pair of unpacked (base 10) BCD values. The AX register is
the implied source and destination operand for this instruction. The AAM
instruction is only useful when it follows a... | manticore/native/cpu/x86.py | def AAM(cpu, imm=None):
"""
ASCII adjust AX after multiply.
Adjusts the result of the multiplication of two unpacked BCD values
to create a pair of unpacked (base 10) BCD values. The AX register is
the implied source and destination operand for this instruction. The AAM
... | def AAM(cpu, imm=None):
"""
ASCII adjust AX after multiply.
Adjusts the result of the multiplication of two unpacked BCD values
to create a pair of unpacked (base 10) BCD values. The AX register is
the implied source and destination operand for this instruction. The AAM
... | [
"ASCII",
"adjust",
"AX",
"after",
"multiply",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1100-L1132 | [
"def",
"AAM",
"(",
"cpu",
",",
"imm",
"=",
"None",
")",
":",
"if",
"imm",
"is",
"None",
":",
"imm",
"=",
"10",
"else",
":",
"imm",
"=",
"imm",
".",
"read",
"(",
")",
"cpu",
".",
"AH",
"=",
"Operators",
".",
"UDIV",
"(",
"cpu",
".",
"AL",
",... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.AAS | ASCII Adjust AL after subtraction.
Adjusts the result of the subtraction of two unpacked BCD values to create a unpacked
BCD result. The AL register is the implied source and destination operand for this instruction.
The AAS instruction is only useful when it follows a SUB instruction that sub... | manticore/native/cpu/x86.py | def AAS(cpu):
"""
ASCII Adjust AL after subtraction.
Adjusts the result of the subtraction of two unpacked BCD values to create a unpacked
BCD result. The AL register is the implied source and destination operand for this instruction.
The AAS instruction is only useful when it ... | def AAS(cpu):
"""
ASCII Adjust AL after subtraction.
Adjusts the result of the subtraction of two unpacked BCD values to create a unpacked
BCD result. The AL register is the implied source and destination operand for this instruction.
The AAS instruction is only useful when it ... | [
"ASCII",
"Adjust",
"AL",
"after",
"subtraction",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1135-L1177 | [
"def",
"AAS",
"(",
"cpu",
")",
":",
"if",
"(",
"cpu",
".",
"AL",
"&",
"0x0F",
">",
"9",
")",
"or",
"cpu",
".",
"AF",
"==",
"1",
":",
"cpu",
".",
"AX",
"=",
"cpu",
".",
"AX",
"-",
"6",
"cpu",
".",
"AH",
"=",
"cpu",
".",
"AH",
"-",
"1",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.ADC | Adds with carry.
Adds the destination operand (first operand), the source operand (second operand),
and the carry (CF) flag and stores the result in the destination operand. The state
of the CF flag represents a carry from a previous addition. When an immediate value
is used as an opera... | manticore/native/cpu/x86.py | def ADC(cpu, dest, src):
"""
Adds with carry.
Adds the destination operand (first operand), the source operand (second operand),
and the carry (CF) flag and stores the result in the destination operand. The state
of the CF flag represents a carry from a previous addition. When a... | def ADC(cpu, dest, src):
"""
Adds with carry.
Adds the destination operand (first operand), the source operand (second operand),
and the carry (CF) flag and stores the result in the destination operand. The state
of the CF flag represents a carry from a previous addition. When a... | [
"Adds",
"with",
"carry",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1180-L1203 | [
"def",
"ADC",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"cpu",
".",
"_ADD",
"(",
"dest",
",",
"src",
",",
"carry",
"=",
"True",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.ADD | Add.
Adds the first operand (destination operand) and the second operand (source operand)
and stores the result in the destination operand. When an immediate value is used as
an operand, it is sign-extended to the length of the destination operand format.
The ADD instruction does not di... | manticore/native/cpu/x86.py | def ADD(cpu, dest, src):
"""
Add.
Adds the first operand (destination operand) and the second operand (source operand)
and stores the result in the destination operand. When an immediate value is used as
an operand, it is sign-extended to the length of the destination operand fo... | def ADD(cpu, dest, src):
"""
Add.
Adds the first operand (destination operand) and the second operand (source operand)
and stores the result in the destination operand. When an immediate value is used as
an operand, it is sign-extended to the length of the destination operand fo... | [
"Add",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1206-L1224 | [
"def",
"ADD",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"cpu",
".",
"_ADD",
"(",
"dest",
",",
"src",
",",
"carry",
"=",
"False",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMP | Compares two operands.
Compares the first source operand with the second source operand and sets the status flags
in the EFLAGS register according to the results. The comparison is performed by subtracting
the second operand from the first operand and then setting the status flags in the same m... | manticore/native/cpu/x86.py | def CMP(cpu, src1, src2):
"""
Compares two operands.
Compares the first source operand with the second source operand and sets the status flags
in the EFLAGS register according to the results. The comparison is performed by subtracting
the second operand from the first operand a... | def CMP(cpu, src1, src2):
"""
Compares two operands.
Compares the first source operand with the second source operand and sets the status flags
in the EFLAGS register according to the results. The comparison is performed by subtracting
the second operand from the first operand a... | [
"Compares",
"two",
"operands",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1256-L1279 | [
"def",
"CMP",
"(",
"cpu",
",",
"src1",
",",
"src2",
")",
":",
"arg0",
"=",
"src1",
".",
"read",
"(",
")",
"arg1",
"=",
"Operators",
".",
"SEXTEND",
"(",
"src2",
".",
"read",
"(",
")",
",",
"src2",
".",
"size",
",",
"src1",
".",
"size",
")",
"... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMPXCHG | Compares and exchanges.
Compares the value in the AL, AX, EAX or RAX register (depending on the
size of the operand) with the first operand (destination operand). If
the two values are equal, the second operand (source operand) is loaded
into the destination operand. Otherwise, the dest... | manticore/native/cpu/x86.py | def CMPXCHG(cpu, dest, src):
"""
Compares and exchanges.
Compares the value in the AL, AX, EAX or RAX register (depending on the
size of the operand) with the first operand (destination operand). If
the two values are equal, the second operand (source operand) is loaded
... | def CMPXCHG(cpu, dest, src):
"""
Compares and exchanges.
Compares the value in the AL, AX, EAX or RAX register (depending on the
size of the operand) with the first operand (destination operand). If
the two values are equal, the second operand (source operand) is loaded
... | [
"Compares",
"and",
"exchanges",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1282-L1322 | [
"def",
"CMPXCHG",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"size",
"=",
"dest",
".",
"size",
"reg_name",
"=",
"{",
"8",
":",
"'AL'",
",",
"16",
":",
"'AX'",
",",
"32",
":",
"'EAX'",
",",
"64",
":",
"'RAX'",
"}",
"[",
"size",
"]",
"accum... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMPXCHG8B | Compares and exchanges bytes.
Compares the 64-bit value in EDX:EAX (or 128-bit value in RDX:RAX if
operand size is 128 bits) with the operand (destination operand). If
the values are equal, the 64-bit value in ECX:EBX (or 128-bit value in
RCX:RBX) is stored in the destination operand. ... | manticore/native/cpu/x86.py | def CMPXCHG8B(cpu, dest):
"""
Compares and exchanges bytes.
Compares the 64-bit value in EDX:EAX (or 128-bit value in RDX:RAX if
operand size is 128 bits) with the operand (destination operand). If
the values are equal, the 64-bit value in ECX:EBX (or 128-bit value in
RC... | def CMPXCHG8B(cpu, dest):
"""
Compares and exchanges bytes.
Compares the 64-bit value in EDX:EAX (or 128-bit value in RDX:RAX if
operand size is 128 bits) with the operand (destination operand). If
the values are equal, the 64-bit value in ECX:EBX (or 128-bit value in
RC... | [
"Compares",
"and",
"exchanges",
"bytes",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1325-L1385 | [
"def",
"CMPXCHG8B",
"(",
"cpu",
",",
"dest",
")",
":",
"size",
"=",
"dest",
".",
"size",
"cmp_reg_name_l",
"=",
"{",
"64",
":",
"'EAX'",
",",
"128",
":",
"'RAX'",
"}",
"[",
"size",
"]",
"cmp_reg_name_h",
"=",
"{",
"64",
":",
"'EDX'",
",",
"128",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.DAA | Decimal adjusts AL after addition.
Adjusts the sum of two packed BCD values to create a packed BCD result. The AL register
is the implied source and destination operand. If a decimal carry is detected, the CF
and AF flags are set accordingly.
The CF and AF flags are set if the adjustmen... | manticore/native/cpu/x86.py | def DAA(cpu):
"""
Decimal adjusts AL after addition.
Adjusts the sum of two packed BCD values to create a packed BCD result. The AL register
is the implied source and destination operand. If a decimal carry is detected, the CF
and AF flags are set accordingly.
The CF and... | def DAA(cpu):
"""
Decimal adjusts AL after addition.
Adjusts the sum of two packed BCD values to create a packed BCD result. The AL register
is the implied source and destination operand. If a decimal carry is detected, the CF
and AF flags are set accordingly.
The CF and... | [
"Decimal",
"adjusts",
"AL",
"after",
"addition",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1388-L1445 | [
"def",
"DAA",
"(",
"cpu",
")",
":",
"cpu",
".",
"AF",
"=",
"Operators",
".",
"OR",
"(",
"(",
"cpu",
".",
"AL",
"&",
"0x0f",
")",
">",
"9",
",",
"cpu",
".",
"AF",
")",
"oldAL",
"=",
"cpu",
".",
"AL",
"cpu",
".",
"AL",
"=",
"Operators",
".",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.DAS | Decimal adjusts AL after subtraction.
Adjusts the result of the subtraction of two packed BCD values to create a packed BCD result.
The AL register is the implied source and destination operand. If a decimal borrow is detected,
the CF and AF flags are set accordingly. This instruction is not va... | manticore/native/cpu/x86.py | def DAS(cpu):
"""
Decimal adjusts AL after subtraction.
Adjusts the result of the subtraction of two packed BCD values to create a packed BCD result.
The AL register is the implied source and destination operand. If a decimal borrow is detected,
the CF and AF flags are set accor... | def DAS(cpu):
"""
Decimal adjusts AL after subtraction.
Adjusts the result of the subtraction of two packed BCD values to create a packed BCD result.
The AL register is the implied source and destination operand. If a decimal borrow is detected,
the CF and AF flags are set accor... | [
"Decimal",
"adjusts",
"AL",
"after",
"subtraction",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1448-L1497 | [
"def",
"DAS",
"(",
"cpu",
")",
":",
"oldAL",
"=",
"cpu",
".",
"AL",
"oldCF",
"=",
"cpu",
".",
"CF",
"cpu",
".",
"AF",
"=",
"Operators",
".",
"OR",
"(",
"(",
"cpu",
".",
"AL",
"&",
"0x0f",
")",
">",
"9",
",",
"cpu",
".",
"AF",
")",
"cpu",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.DIV | Unsigned divide.
Divides (unsigned) the value in the AX register, DX:AX register pair,
or EDX:EAX or RDX:RAX register pair (dividend) by the source operand
(divisor) and stores the result in the AX (AH:AL), DX:AX, EDX:EAX or
RDX:RAX registers. The source operand can be a general-purpose... | manticore/native/cpu/x86.py | def DIV(cpu, src):
"""
Unsigned divide.
Divides (unsigned) the value in the AX register, DX:AX register pair,
or EDX:EAX or RDX:RAX register pair (dividend) by the source operand
(divisor) and stores the result in the AX (AH:AL), DX:AX, EDX:EAX or
RDX:RAX registers. The ... | def DIV(cpu, src):
"""
Unsigned divide.
Divides (unsigned) the value in the AX register, DX:AX register pair,
or EDX:EAX or RDX:RAX register pair (dividend) by the source operand
(divisor) and stores the result in the AX (AH:AL), DX:AX, EDX:EAX or
RDX:RAX registers. The ... | [
"Unsigned",
"divide",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1530-L1613 | [
"def",
"DIV",
"(",
"cpu",
",",
"src",
")",
":",
"size",
"=",
"src",
".",
"size",
"reg_name_h",
"=",
"{",
"8",
":",
"'DL'",
",",
"16",
":",
"'DX'",
",",
"32",
":",
"'EDX'",
",",
"64",
":",
"'RDX'",
"}",
"[",
"size",
"]",
"reg_name_l",
"=",
"{"... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.IDIV | Signed divide.
Divides (signed) the value in the AL, AX, or EAX register by the source
operand and stores the result in the AX, DX:AX, or EDX:EAX registers.
The source operand can be a general-purpose register or a memory
location. The action of this instruction depends on the operand s... | manticore/native/cpu/x86.py | def IDIV(cpu, src):
"""
Signed divide.
Divides (signed) the value in the AL, AX, or EAX register by the source
operand and stores the result in the AX, DX:AX, or EDX:EAX registers.
The source operand can be a general-purpose register or a memory
location. The action of t... | def IDIV(cpu, src):
"""
Signed divide.
Divides (signed) the value in the AL, AX, or EAX register by the source
operand and stores the result in the AX, DX:AX, or EDX:EAX registers.
The source operand can be a general-purpose register or a memory
location. The action of t... | [
"Signed",
"divide",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1618-L1710 | [
"def",
"IDIV",
"(",
"cpu",
",",
"src",
")",
":",
"reg_name_h",
"=",
"{",
"8",
":",
"'AH'",
",",
"16",
":",
"'DX'",
",",
"32",
":",
"'EDX'",
",",
"64",
":",
"'RDX'",
"}",
"[",
"src",
".",
"size",
"]",
"reg_name_l",
"=",
"{",
"8",
":",
"'AL'",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.IMUL | Signed multiply.
Performs a signed multiplication of two operands. This instruction has
three forms, depending on the number of operands.
- One-operand form. This form is identical to that used by the MUL
instruction. Here, the source operand (in a general-purpose
re... | manticore/native/cpu/x86.py | def IMUL(cpu, *operands):
"""
Signed multiply.
Performs a signed multiplication of two operands. This instruction has
three forms, depending on the number of operands.
- One-operand form. This form is identical to that used by the MUL
instruction. Here, the sourc... | def IMUL(cpu, *operands):
"""
Signed multiply.
Performs a signed multiplication of two operands. This instruction has
three forms, depending on the number of operands.
- One-operand form. This form is identical to that used by the MUL
instruction. Here, the sourc... | [
"Signed",
"multiply",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1715-L1857 | [
"def",
"IMUL",
"(",
"cpu",
",",
"*",
"operands",
")",
":",
"dest",
"=",
"operands",
"[",
"0",
"]",
"OperandSize",
"=",
"dest",
".",
"size",
"reg_name_h",
"=",
"{",
"8",
":",
"'AH'",
",",
"16",
":",
"'DX'",
",",
"32",
":",
"'EDX'",
",",
"64",
":... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.INC | Increments by 1.
Adds 1 to the destination operand, while preserving the state of the
CF flag. The destination operand can be a register or a memory location.
This instruction allows a loop counter to be updated without disturbing
the CF flag. (Use a ADD instruction with an immediate op... | manticore/native/cpu/x86.py | def INC(cpu, dest):
"""
Increments by 1.
Adds 1 to the destination operand, while preserving the state of the
CF flag. The destination operand can be a register or a memory location.
This instruction allows a loop counter to be updated without disturbing
the CF flag. (Us... | def INC(cpu, dest):
"""
Increments by 1.
Adds 1 to the destination operand, while preserving the state of the
CF flag. The destination operand can be a register or a memory location.
This instruction allows a loop counter to be updated without disturbing
the CF flag. (Us... | [
"Increments",
"by",
"1",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1860-L1883 | [
"def",
"INC",
"(",
"cpu",
",",
"dest",
")",
":",
"arg0",
"=",
"dest",
".",
"read",
"(",
")",
"res",
"=",
"dest",
".",
"write",
"(",
"arg0",
"+",
"1",
")",
"res",
"&=",
"(",
"1",
"<<",
"dest",
".",
"size",
")",
"-",
"1",
"SIGN_MASK",
"=",
"1... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.MUL | Unsigned multiply.
Performs an unsigned multiplication of the first operand (destination
operand) and the second operand (source operand) and stores the result
in the destination operand. The destination operand is an implied operand
located in register AL, AX or EAX (depending on the s... | manticore/native/cpu/x86.py | def MUL(cpu, src):
"""
Unsigned multiply.
Performs an unsigned multiplication of the first operand (destination
operand) and the second operand (source operand) and stores the result
in the destination operand. The destination operand is an implied operand
located in reg... | def MUL(cpu, src):
"""
Unsigned multiply.
Performs an unsigned multiplication of the first operand (destination
operand) and the second operand (source operand) and stores the result
in the destination operand. The destination operand is an implied operand
located in reg... | [
"Unsigned",
"multiply",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1886-L1927 | [
"def",
"MUL",
"(",
"cpu",
",",
"src",
")",
":",
"size",
"=",
"src",
".",
"size",
"reg_name_low",
",",
"reg_name_high",
"=",
"{",
"8",
":",
"(",
"'AL'",
",",
"'AH'",
")",
",",
"16",
":",
"(",
"'AX'",
",",
"'DX'",
")",
",",
"32",
":",
"(",
"'EA... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.NEG | Two's complement negation.
Replaces the value of operand (the destination operand) with its two's complement.
(This operation is equivalent to subtracting the operand from 0.) The destination operand is
located in a general-purpose register or a memory location::
IF DEST = 0
... | manticore/native/cpu/x86.py | def NEG(cpu, dest):
"""
Two's complement negation.
Replaces the value of operand (the destination operand) with its two's complement.
(This operation is equivalent to subtracting the operand from 0.) The destination operand is
located in a general-purpose register or a memory lo... | def NEG(cpu, dest):
"""
Two's complement negation.
Replaces the value of operand (the destination operand) with its two's complement.
(This operation is equivalent to subtracting the operand from 0.) The destination operand is
located in a general-purpose register or a memory lo... | [
"Two",
"s",
"complement",
"negation",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1930-L1951 | [
"def",
"NEG",
"(",
"cpu",
",",
"dest",
")",
":",
"source",
"=",
"dest",
".",
"read",
"(",
")",
"res",
"=",
"dest",
".",
"write",
"(",
"-",
"source",
")",
"cpu",
".",
"_calculate_logic_flags",
"(",
"dest",
".",
"size",
",",
"res",
")",
"cpu",
".",... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.SBB | Integer subtraction with borrow.
Adds the source operand (second operand) and the carry (CF) flag, and
subtracts the result from the destination operand (first operand). The
result of the subtraction is stored in the destination operand. The
destination operand can be a register or a me... | manticore/native/cpu/x86.py | def SBB(cpu, dest, src):
"""
Integer subtraction with borrow.
Adds the source operand (second operand) and the carry (CF) flag, and
subtracts the result from the destination operand (first operand). The
result of the subtraction is stored in the destination operand. The
... | def SBB(cpu, dest, src):
"""
Integer subtraction with borrow.
Adds the source operand (second operand) and the carry (CF) flag, and
subtracts the result from the destination operand (first operand). The
result of the subtraction is stored in the destination operand. The
... | [
"Integer",
"subtraction",
"with",
"borrow",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1954-L1981 | [
"def",
"SBB",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"cpu",
".",
"_SUB",
"(",
"dest",
",",
"src",
",",
"carry",
"=",
"True",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.SUB | Subtract.
Subtracts the second operand (source operand) from the first operand
(destination operand) and stores the result in the destination operand.
The destination operand can be a register or a memory location; the
source operand can be an immediate, register, or memory location.
... | manticore/native/cpu/x86.py | def SUB(cpu, dest, src):
"""
Subtract.
Subtracts the second operand (source operand) from the first operand
(destination operand) and stores the result in the destination operand.
The destination operand can be a register or a memory location; the
source operand can be a... | def SUB(cpu, dest, src):
"""
Subtract.
Subtracts the second operand (source operand) from the first operand
(destination operand) and stores the result in the destination operand.
The destination operand can be a register or a memory location; the
source operand can be a... | [
"Subtract",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L1984-L2007 | [
"def",
"SUB",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"cpu",
".",
"_SUB",
"(",
"dest",
",",
"src",
",",
"carry",
"=",
"False",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.XADD | Exchanges and adds.
Exchanges the first operand (destination operand) with the second operand
(source operand), then loads the sum of the two values into the destination
operand. The destination operand can be a register or a memory location;
the source operand is a register.
Th... | manticore/native/cpu/x86.py | def XADD(cpu, dest, src):
"""
Exchanges and adds.
Exchanges the first operand (destination operand) with the second operand
(source operand), then loads the sum of the two values into the destination
operand. The destination operand can be a register or a memory location;
... | def XADD(cpu, dest, src):
"""
Exchanges and adds.
Exchanges the first operand (destination operand) with the second operand
(source operand), then loads the sum of the two values into the destination
operand. The destination operand can be a register or a memory location;
... | [
"Exchanges",
"and",
"adds",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2026-L2060 | [
"def",
"XADD",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"MASK",
"=",
"(",
"1",
"<<",
"dest",
".",
"size",
")",
"-",
"1",
"SIGN_MASK",
"=",
"1",
"<<",
"(",
"dest",
".",
"size",
"-",
"1",
")",
"arg0",
"=",
"dest",
".",
"read",
"(",
")",... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.BSWAP | Byte swap.
Reverses the byte order of a 32-bit (destination) register: bits 0 through
7 are swapped with bits 24 through 31, and bits 8 through 15 are swapped
with bits 16 through 23. This instruction is provided for converting little-endian
values to big-endian format and vice versa.
... | manticore/native/cpu/x86.py | def BSWAP(cpu, dest):
"""
Byte swap.
Reverses the byte order of a 32-bit (destination) register: bits 0 through
7 are swapped with bits 24 through 31, and bits 8 through 15 are swapped
with bits 16 through 23. This instruction is provided for converting little-endian
val... | def BSWAP(cpu, dest):
"""
Byte swap.
Reverses the byte order of a 32-bit (destination) register: bits 0 through
7 are swapped with bits 24 through 31, and bits 8 through 15 are swapped
with bits 16 through 23. This instruction is provided for converting little-endian
val... | [
"Byte",
"swap",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2073-L2099 | [
"def",
"BSWAP",
"(",
"cpu",
",",
"dest",
")",
":",
"parts",
"=",
"[",
"]",
"arg0",
"=",
"dest",
".",
"read",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"dest",
".",
"size",
",",
"8",
")",
":",
"parts",
".",
"append",
"(",
"Operators"... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVB | Conditional move - Below/not above or equal.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
... | manticore/native/cpu/x86.py | def CMOVB(cpu, dest, src):
"""
Conditional move - Below/not above or equal.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CP... | def CMOVB(cpu, dest, src):
"""
Conditional move - Below/not above or equal.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CP... | [
"Conditional",
"move",
"-",
"Below",
"/",
"not",
"above",
"or",
"equal",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2111-L2123 | [
"def",
"CMOVB",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"CF",
",",
"src",
".",
"read",
"(",
")",
",",
"dest",
".",
"read",
"(",
")",
")",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVA | Conditional move - Above/not below or equal.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
... | manticore/native/cpu/x86.py | def CMOVA(cpu, dest, src):
"""
Conditional move - Above/not below or equal.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CP... | def CMOVA(cpu, dest, src):
"""
Conditional move - Above/not below or equal.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CP... | [
"Conditional",
"move",
"-",
"Above",
"/",
"not",
"below",
"or",
"equal",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2127-L2139 | [
"def",
"CMOVA",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"Operators",
".",
"AND",
"(",
"cpu",
".",
"CF",
"==",
"False",
",",
"cpu",
".",
"ZF",
"==",
"Fal... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVAE | Conditional move - Above or equal/not below.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
... | manticore/native/cpu/x86.py | def CMOVAE(cpu, dest, src):
"""
Conditional move - Above or equal/not below.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current C... | def CMOVAE(cpu, dest, src):
"""
Conditional move - Above or equal/not below.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current C... | [
"Conditional",
"move",
"-",
"Above",
"or",
"equal",
"/",
"not",
"below",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2143-L2155 | [
"def",
"CMOVAE",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"CF",
"==",
"False",
",",
"src",
".",
"read",
"(",
")",
",",
"dest",
".",
"read",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVBE | Conditional move - Below or equal/not above.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
... | manticore/native/cpu/x86.py | def CMOVBE(cpu, dest, src):
"""
Conditional move - Below or equal/not above.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current C... | def CMOVBE(cpu, dest, src):
"""
Conditional move - Below or equal/not above.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current C... | [
"Conditional",
"move",
"-",
"Below",
"or",
"equal",
"/",
"not",
"above",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2159-L2171 | [
"def",
"CMOVBE",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"Operators",
".",
"OR",
"(",
"cpu",
".",
"CF",
",",
"cpu",
".",
"ZF",
")",
",",
"src",
".",
"... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVZ | Conditional move - Equal/zero.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
:param s... | manticore/native/cpu/x86.py | def CMOVZ(cpu, dest, src):
"""
Conditional move - Equal/zero.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:pa... | def CMOVZ(cpu, dest, src):
"""
Conditional move - Equal/zero.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:pa... | [
"Conditional",
"move",
"-",
"Equal",
"/",
"zero",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2174-L2186 | [
"def",
"CMOVZ",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"ZF",
",",
"src",
".",
"read",
"(",
")",
",",
"dest",
".",
"read",
"(",
")",
")",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVNZ | Conditional move - Not equal/not zero.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
... | manticore/native/cpu/x86.py | def CMOVNZ(cpu, dest, src):
"""
Conditional move - Not equal/not zero.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
... | def CMOVNZ(cpu, dest, src):
"""
Conditional move - Not equal/not zero.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
... | [
"Conditional",
"move",
"-",
"Not",
"equal",
"/",
"not",
"zero",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2189-L2201 | [
"def",
"CMOVNZ",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"ZF",
"==",
"False",
",",
"src",
".",
"read",
"(",
")",
",",
"dest",
".",
"read",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVP | Conditional move - Parity/parity even.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
... | manticore/native/cpu/x86.py | def CMOVP(cpu, dest, src):
"""
Conditional move - Parity/parity even.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
... | def CMOVP(cpu, dest, src):
"""
Conditional move - Parity/parity even.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
... | [
"Conditional",
"move",
"-",
"Parity",
"/",
"parity",
"even",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2205-L2217 | [
"def",
"CMOVP",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"PF",
",",
"src",
".",
"read",
"(",
")",
",",
"dest",
".",
"read",
"(",
")",
")",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVNP | Conditional move - Not parity/parity odd.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
... | manticore/native/cpu/x86.py | def CMOVNP(cpu, dest, src):
"""
Conditional move - Not parity/parity odd.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.... | def CMOVNP(cpu, dest, src):
"""
Conditional move - Not parity/parity odd.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.... | [
"Conditional",
"move",
"-",
"Not",
"parity",
"/",
"parity",
"odd",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2221-L2233 | [
"def",
"CMOVNP",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"PF",
"==",
"False",
",",
"src",
".",
"read",
"(",
")",
",",
"dest",
".",
"read",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVG | Conditional move - Greater.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
:param src:... | manticore/native/cpu/x86.py | def CMOVG(cpu, dest, src):
"""
Conditional move - Greater.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param... | def CMOVG(cpu, dest, src):
"""
Conditional move - Greater.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param... | [
"Conditional",
"move",
"-",
"Greater",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2242-L2254 | [
"def",
"CMOVG",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"Operators",
".",
"AND",
"(",
"cpu",
".",
"ZF",
"==",
"0",
",",
"cpu",
".",
"SF",
"==",
"cpu",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVGE | Conditional move - Greater or equal/not less.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
... | manticore/native/cpu/x86.py | def CMOVGE(cpu, dest, src):
"""
Conditional move - Greater or equal/not less.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current ... | def CMOVGE(cpu, dest, src):
"""
Conditional move - Greater or equal/not less.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current ... | [
"Conditional",
"move",
"-",
"Greater",
"or",
"equal",
"/",
"not",
"less",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2258-L2270 | [
"def",
"CMOVGE",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"(",
"cpu",
".",
"SF",
"^",
"cpu",
".",
"OF",
")",
"==",
"0",
",",
"src",
".",
"read",
"(",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVLE | Conditional move - Less or equal/not greater.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
... | manticore/native/cpu/x86.py | def CMOVLE(cpu, dest, src):
"""
Conditional move - Less or equal/not greater.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current ... | def CMOVLE(cpu, dest, src):
"""
Conditional move - Less or equal/not greater.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current ... | [
"Conditional",
"move",
"-",
"Less",
"or",
"equal",
"/",
"not",
"greater",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2290-L2302 | [
"def",
"CMOVLE",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"Operators",
".",
"OR",
"(",
"cpu",
".",
"SF",
"^",
"cpu",
".",
"OF",
",",
"cpu",
".",
"ZF",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVO | Conditional move - Overflow.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
:param src... | manticore/native/cpu/x86.py | def CMOVO(cpu, dest, src):
"""
Conditional move - Overflow.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:para... | def CMOVO(cpu, dest, src):
"""
Conditional move - Overflow.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:para... | [
"Conditional",
"move",
"-",
"Overflow",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2305-L2317 | [
"def",
"CMOVO",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"OF",
",",
"src",
".",
"read",
"(",
")",
",",
"dest",
".",
"read",
"(",
")",
")",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVNO | Conditional move - Not overflow.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
:param... | manticore/native/cpu/x86.py | def CMOVNO(cpu, dest, src):
"""
Conditional move - Not overflow.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
... | def CMOVNO(cpu, dest, src):
"""
Conditional move - Not overflow.
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
... | [
"Conditional",
"move",
"-",
"Not",
"overflow",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2320-L2332 | [
"def",
"CMOVNO",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"OF",
"==",
"False",
",",
"src",
".",
"read",
"(",
")",
",",
"dest",
".",
"read",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVS | Conditional move - Sign (negative).
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
:pa... | manticore/native/cpu/x86.py | def CMOVS(cpu, dest, src):
"""
Conditional move - Sign (negative).
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
... | def CMOVS(cpu, dest, src):
"""
Conditional move - Sign (negative).
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
... | [
"Conditional",
"move",
"-",
"Sign",
"(",
"negative",
")",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2335-L2347 | [
"def",
"CMOVS",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"SF",
",",
"src",
".",
"read",
"(",
")",
",",
"dest",
".",
"read",
"(",
")",
")",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.CMOVNS | Conditional move - Not sign (non-negative).
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CPU.
:param dest: destination operand.
... | manticore/native/cpu/x86.py | def CMOVNS(cpu, dest, src):
"""
Conditional move - Not sign (non-negative).
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CP... | def CMOVNS(cpu, dest, src):
"""
Conditional move - Not sign (non-negative).
Tests the status flags in the EFLAGS register and moves the source operand
(second operand) to the destination operand (first operand) if the given
test condition is true.
:param cpu: current CP... | [
"Conditional",
"move",
"-",
"Not",
"sign",
"(",
"non",
"-",
"negative",
")",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2350-L2362 | [
"def",
"CMOVNS",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"SF",
"==",
"False",
",",
"src",
".",
"read",
"(",
")",
",",
"dest",
".",
"read",
... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.LAHF | Loads status flags into AH register.
Moves the low byte of the EFLAGS register (which includes status flags
SF, ZF, AF, PF, and CF) to the AH register. Reserved bits 1, 3, and 5
of the EFLAGS register are set in the AH register::
AH = EFLAGS(SF:ZF:0:AF:0:PF:1:CF);
:p... | manticore/native/cpu/x86.py | def LAHF(cpu):
"""
Loads status flags into AH register.
Moves the low byte of the EFLAGS register (which includes status flags
SF, ZF, AF, PF, and CF) to the AH register. Reserved bits 1, 3, and 5
of the EFLAGS register are set in the AH register::
AH = EFLAGS... | def LAHF(cpu):
"""
Loads status flags into AH register.
Moves the low byte of the EFLAGS register (which includes status flags
SF, ZF, AF, PF, and CF) to the AH register. Reserved bits 1, 3, and 5
of the EFLAGS register are set in the AH register::
AH = EFLAGS... | [
"Loads",
"status",
"flags",
"into",
"AH",
"register",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2365-L2397 | [
"def",
"LAHF",
"(",
"cpu",
")",
":",
"used_regs",
"=",
"(",
"cpu",
".",
"SF",
",",
"cpu",
".",
"ZF",
",",
"cpu",
".",
"AF",
",",
"cpu",
".",
"PF",
",",
"cpu",
".",
"CF",
")",
"is_expression",
"=",
"any",
"(",
"issymbolic",
"(",
"x",
")",
"for... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.LEA | Loads effective address.
Computes the effective address of the second operand (the source operand) and stores it in the first operand
(destination operand). The source operand is a memory address (offset part) specified with one of the processors
addressing modes; the destination operand is a g... | manticore/native/cpu/x86.py | def LEA(cpu, dest, src):
"""
Loads effective address.
Computes the effective address of the second operand (the source operand) and stores it in the first operand
(destination operand). The source operand is a memory address (offset part) specified with one of the processors
add... | def LEA(cpu, dest, src):
"""
Loads effective address.
Computes the effective address of the second operand (the source operand) and stores it in the first operand
(destination operand). The source operand is a memory address (offset part) specified with one of the processors
add... | [
"Loads",
"effective",
"address",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2501-L2516 | [
"def",
"LEA",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"EXTRACT",
"(",
"src",
".",
"address",
"(",
")",
",",
"0",
",",
"dest",
".",
"size",
")",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.MOVBE | Moves data after swapping bytes.
Performs a byte swap operation on the data copied from the second operand (source operand) and store the result
in the first operand (destination operand). The source operand can be a general-purpose register, or memory location; the destination register can be a genera... | manticore/native/cpu/x86.py | def MOVBE(cpu, dest, src):
"""
Moves data after swapping bytes.
Performs a byte swap operation on the data copied from the second operand (source operand) and store the result
in the first operand (destination operand). The source operand can be a general-purpose register, or memory loc... | def MOVBE(cpu, dest, src):
"""
Moves data after swapping bytes.
Performs a byte swap operation on the data copied from the second operand (source operand) and store the result
in the first operand (destination operand). The source operand can be a general-purpose register, or memory loc... | [
"Moves",
"data",
"after",
"swapping",
"bytes",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2538-L2581 | [
"def",
"MOVBE",
"(",
"cpu",
",",
"dest",
",",
"src",
")",
":",
"size",
"=",
"dest",
".",
"size",
"arg0",
"=",
"dest",
".",
"read",
"(",
")",
"temp",
"=",
"0",
"for",
"pos",
"in",
"range",
"(",
"0",
",",
"size",
",",
"8",
")",
":",
"temp",
"... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.SAHF | Stores AH into flags.
Loads the SF, ZF, AF, PF, and CF flags of the EFLAGS register with values
from the corresponding bits in the AH register (bits 7, 6, 4, 2, and 0,
respectively). Bits 1, 3, and 5 of register AH are ignored; the corresponding
reserved bits (1, 3, and 5) in the EFLAGS... | manticore/native/cpu/x86.py | def SAHF(cpu):
"""
Stores AH into flags.
Loads the SF, ZF, AF, PF, and CF flags of the EFLAGS register with values
from the corresponding bits in the AH register (bits 7, 6, 4, 2, and 0,
respectively). Bits 1, 3, and 5 of register AH are ignored; the corresponding
reserv... | def SAHF(cpu):
"""
Stores AH into flags.
Loads the SF, ZF, AF, PF, and CF flags of the EFLAGS register with values
from the corresponding bits in the AH register (bits 7, 6, 4, 2, and 0,
respectively). Bits 1, 3, and 5 of register AH are ignored; the corresponding
reserv... | [
"Stores",
"AH",
"into",
"flags",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2584-L2603 | [
"def",
"SAHF",
"(",
"cpu",
")",
":",
"eflags_size",
"=",
"32",
"val",
"=",
"cpu",
".",
"AH",
"&",
"0xD5",
"|",
"0x02",
"cpu",
".",
"EFLAGS",
"=",
"Operators",
".",
"ZEXTEND",
"(",
"val",
",",
"eflags_size",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.SETA | Sets byte if above.
Sets the destination operand to 0 or 1 depending on the settings of the status flags (CF, SF, OF, ZF, and PF, 1, 0) in the
EFLAGS register. The destination operand points to a byte register or a byte in memory. The condition code suffix
(cc, 1, 0) indicates the condition bei... | manticore/native/cpu/x86.py | def SETA(cpu, dest):
"""
Sets byte if above.
Sets the destination operand to 0 or 1 depending on the settings of the status flags (CF, SF, OF, ZF, and PF, 1, 0) in the
EFLAGS register. The destination operand points to a byte register or a byte in memory. The condition code suffix
... | def SETA(cpu, dest):
"""
Sets byte if above.
Sets the destination operand to 0 or 1 depending on the settings of the status flags (CF, SF, OF, ZF, and PF, 1, 0) in the
EFLAGS register. The destination operand points to a byte register or a byte in memory. The condition code suffix
... | [
"Sets",
"byte",
"if",
"above",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2606-L2623 | [
"def",
"SETA",
"(",
"cpu",
",",
"dest",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"Operators",
".",
"OR",
"(",
"cpu",
".",
"CF",
",",
"cpu",
".",
"ZF",
")",
"==",
"False",
",",
"1",
",",
"0... | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.SETB | Sets byte if below.
:param cpu: current CPU.
:param dest: destination operand. | manticore/native/cpu/x86.py | def SETB(cpu, dest):
"""
Sets byte if below.
:param cpu: current CPU.
:param dest: destination operand.
"""
dest.write(Operators.ITEBV(dest.size, cpu.CF, 1, 0)) | def SETB(cpu, dest):
"""
Sets byte if below.
:param cpu: current CPU.
:param dest: destination operand.
"""
dest.write(Operators.ITEBV(dest.size, cpu.CF, 1, 0)) | [
"Sets",
"byte",
"if",
"below",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2636-L2643 | [
"def",
"SETB",
"(",
"cpu",
",",
"dest",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"CF",
",",
"1",
",",
"0",
")",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.SETBE | Sets byte if below or equal.
:param cpu: current CPU.
:param dest: destination operand. | manticore/native/cpu/x86.py | def SETBE(cpu, dest):
"""
Sets byte if below or equal.
:param cpu: current CPU.
:param dest: destination operand.
"""
dest.write(Operators.ITEBV(dest.size, Operators.OR(cpu.CF, cpu.ZF), 1, 0)) | def SETBE(cpu, dest):
"""
Sets byte if below or equal.
:param cpu: current CPU.
:param dest: destination operand.
"""
dest.write(Operators.ITEBV(dest.size, Operators.OR(cpu.CF, cpu.ZF), 1, 0)) | [
"Sets",
"byte",
"if",
"below",
"or",
"equal",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2646-L2653 | [
"def",
"SETBE",
"(",
"cpu",
",",
"dest",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"Operators",
".",
"OR",
"(",
"cpu",
".",
"CF",
",",
"cpu",
".",
"ZF",
")",
",",
"1",
",",
"0",
")",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
valid | X86Cpu.SETC | Sets if carry.
:param cpu: current CPU.
:param dest: destination operand. | manticore/native/cpu/x86.py | def SETC(cpu, dest):
"""
Sets if carry.
:param cpu: current CPU.
:param dest: destination operand.
"""
dest.write(Operators.ITEBV(dest.size, cpu.CF, 1, 0)) | def SETC(cpu, dest):
"""
Sets if carry.
:param cpu: current CPU.
:param dest: destination operand.
"""
dest.write(Operators.ITEBV(dest.size, cpu.CF, 1, 0)) | [
"Sets",
"if",
"carry",
"."
] | trailofbits/manticore | python | https://github.com/trailofbits/manticore/blob/54c5a15b1119c523ae54c09972413e8b97f11629/manticore/native/cpu/x86.py#L2656-L2663 | [
"def",
"SETC",
"(",
"cpu",
",",
"dest",
")",
":",
"dest",
".",
"write",
"(",
"Operators",
".",
"ITEBV",
"(",
"dest",
".",
"size",
",",
"cpu",
".",
"CF",
",",
"1",
",",
"0",
")",
")"
] | 54c5a15b1119c523ae54c09972413e8b97f11629 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.