def test_insert_bytes():
ir = gtirb.IR()
m = gtirb.Module(isa=gtirb.Module.ISA.X64)
m.ir = ir
s = gtirb.Section(name=".text")
s.module = m
bi = gtirb.ByteInterval(contents=b"\x00\x01\x02\x03\x04\x05\x06\x07",
address=0x1000)
bi.section = s
b = gtirb.CodeBlock(offset=2, size=2)
b.byte_interval = bi
b2 = gtirb.DataBlock(offset=6, size=2)
b2.byte_interval = bi
bi.symbolic_expressions[6] = gtirb.SymAddrConst(0, None)
ctx = gtirb_capstone.RewritingContext(ir)
ctx.modify_block_insert(m, b, b"\x08\x09", 1)
assert bi.address == 0x1000
assert bi.size == 10
assert bi.contents == b"\x00\x01\x02\x08\x09\x03\x04\x05\x06\x07"
assert b.offset == 2
assert b.size == 4
assert b2.offset == 8
assert b2.size == 2
assert 6 not in bi.symbolic_expressions
assert 8 in bi.symbolic_expressions
def test_data_blocks(self):
b = gtirb.DataBlock()
self.assertEquals(b.address, None)
self.assertEquals(b.contents, b"")
self.assertEquals(set(b.references), set())
bi = gtirb.ByteInterval(address=1, contents=b"abcd1234")
b.offset = 2
b.size = 3
b.byte_interval = bi
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), set())
s = gtirb.Section()
bi.section = s
m = gtirb.Module(name="M")
sym1 = gtirb.Symbol("test", payload=b)
sym2 = gtirb.Symbol("test", payload=123)
sym3 = gtirb.Symbol("test", payload=b)
m.symbols |= {sym1, sym2, sym3}
s.module = m
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), {sym1, sym3})
def test_proxy_blocks(self):
b = gtirb.ProxyBlock()
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
m = gtirb.Module(name="M")
sym1 = gtirb.Symbol("test", payload=b)
sym2 = gtirb.Symbol("test", payload=123)
sym3 = gtirb.Symbol("test", payload=b)
m.symbols |= {sym1, sym2, sym3}
b.module = m
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
i = gtirb.IR()
m.ir = i
p1 = gtirb.ProxyBlock()
p2 = gtirb.ProxyBlock()
p3 = gtirb.ProxyBlock()
p4 = gtirb.ProxyBlock()
i.cfg.add(gtirb.Edge(b, p1))
i.cfg.add(gtirb.Edge(p2, b))
i.cfg.add(gtirb.Edge(p3, p4))
i.cfg.add(gtirb.Edge(b, b))
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set((s, t) for s, t, l in b.incoming_edges),
{(p2, b), (b, b)})
self.assertEquals(set((s, t) for s, t, l in b.outgoing_edges),
{(b, p1), (b, b)})
def test_from_uuid_typed(self):
nodes = (
gtirb.IR(),
gtirb.Module(),
gtirb.Block(0, 0),
gtirb.DataObject(0, 0),
gtirb.ProxyBlock(),
gtirb.ImageByteMap(),
gtirb.Section("test", 0, 0),
gtirb.Symbol("test"),
)
for node1 in nodes:
with self.subTest(type(node1).__name__):
for node_cls in map(type, nodes):
node2 = None
try:
node2 = node_cls.from_uuid(node1.uuid)
except TypeError:
if node_cls == type(node1):
self.fail(
"%s.from_uuid raised error returning node of"
"its own type" % node_cls)
else:
if node_cls != type(node1):
self.fail("%s.from_uuid returned despite getting"
"argument for a node of type %s" %
(node_cls, type(node1)))
else:
self.assertEqual(node1, node2)
def test_symbols_named(self):
m = gtirb.Module(name="test")
s1 = gtirb.Symbol(name="hello", module=m)
s2 = gtirb.Symbol(name="world", module=m)
found = set(m.symbols_named("hello"))
self.assertEqual(found, {s1})
found = set(m.symbols_named("world"))
self.assertEqual(found, {s2})
# Change the name to verify we update the index
s1.name = "world"
found = set(m.symbols_named("hello"))
self.assertEqual(found, set())
found = set(m.symbols_named("world"))
self.assertEqual(found, {s1, s2})
# Discard the symbol to verify we update the index
m.symbols.discard(s1)
found = set(m.symbols_named("world"))
self.assertEqual(found, {s2})
# Now add it back to verify we update the index
m.symbols.add(s1)
found = set(m.symbols_named("world"))
self.assertEqual(found, {s1, s2})
def test_insert_bytes(self):
ir = gtirb.IR()
m = gtirb.Module()
m.ir = ir
s = gtirb.Section(name=".text")
s.module = m
bi = gtirb.ByteInterval(contents=b"\x00\x01\x02\x03\x04\x05\x06\x07")
bi.section = s
b = gtirb.CodeBlock(offset=2, size=2)
b.byte_interval = bi
b2 = gtirb.DataBlock(offset=6, size=2)
b2.byte_interval = bi
bi.symbolic_expressions[6] = gtirb.SymAddrConst(0, None)
ctx = gtirb_capstone.RewritingContext(ir)
ctx.modify_block_insert(m, b, b"\x08\x09", 1)
self.assertEqual(bi.size, 10)
self.assertEqual(
bi.contents, b"\x00\x01\x02\x08\x09\x03\x04\x05\x06\x07"
)
self.assertEqual(b.offset, 2)
self.assertEqual(b.size, 4)
self.assertEqual(b2.offset, 8)
self.assertEqual(b2.size, 2)
self.assertNotIn(6, bi.symbolic_expressions)
self.assertIn(8, bi.symbolic_expressions)
def test_proxy_blocks(self):
b = gtirb.ProxyBlock()
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
m = gtirb.Module()
sym1 = gtirb.Symbol("test", payload=b)
sym2 = gtirb.Symbol("test", payload=123)
sym3 = gtirb.Symbol("test", payload=b)
m.symbols |= {sym1, sym2, sym3}
b.module = m
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
i = gtirb.IR()
m.ir = i
e1 = gtirb.Edge(b, gtirb.ProxyBlock())
e2 = gtirb.Edge(gtirb.ProxyBlock(), b)
e3 = gtirb.Edge(gtirb.ProxyBlock(), gtirb.ProxyBlock())
e4 = gtirb.Edge(b, b)
i.cfg |= {e1, e2, e3, e4}
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), {e2, e4})
self.assertEquals(set(b.outgoing_edges), {e1, e4})
def create_interval_etc(address, size):
"""
Creates a byte interval and all of the containing structures.
"""
ir = gtirb.IR()
m = gtirb.Module(name="test", ir=ir)
s = gtirb.Section(name=".text", module=m)
bi = gtirb.ByteInterval(address=address, size=size, section=s)
return ir, m, s, bi
def test_code_blocks(self):
b = gtirb.CodeBlock()
self.assertEquals(b.address, None)
self.assertEquals(b.contents, b"")
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
bi = gtirb.ByteInterval(address=1, contents=b"abcd1234")
b.offset = 2
b.size = 3
b.byte_interval = bi
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
s = gtirb.Section()
bi.section = s
m = gtirb.Module(name="M")
sym1 = gtirb.Symbol("test", payload=b)
sym2 = gtirb.Symbol("test", payload=123)
sym3 = gtirb.Symbol("test", payload=b)
m.symbols |= {sym1, sym2, sym3}
s.module = m
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
i = gtirb.IR()
m.ir = i
p1 = gtirb.ProxyBlock()
p2 = gtirb.ProxyBlock()
p3 = gtirb.ProxyBlock()
p4 = gtirb.ProxyBlock()
i.cfg.add(gtirb.Edge(b, p1))
i.cfg.add(gtirb.Edge(p2, b))
i.cfg.add(gtirb.Edge(p3, p4))
i.cfg.add(gtirb.Edge(b, b))
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(
set((s, t) for s, t, l in b.incoming_edges), {(p2, b), (b, b)}
)
self.assertEquals(
set((s, t) for s, t, l in b.outgoing_edges), {(b, p1), (b, b)}
)
def test_byte_intervals_overlapping(self, scope):
ir = gtirb.IR()
m = gtirb.Module(name="test", ir=ir)
s = gtirb.Section(module=m)
search_in = scope.select(ir, m, s, None)
bi1 = gtirb.ByteInterval(address=0x1000, size=8, section=s)
bi2 = gtirb.ByteInterval(address=0x1004, size=4, section=s)
found = set(search_in.byte_intervals_on(0x1005))
self.assertEqual(found, {bi1, bi2})
def test_from_uuid(self):
for node1 in (
gtirb.IR(),
gtirb.Module(),
gtirb.CodeBlock(size=0),
gtirb.DataBlock(size=0),
gtirb.ProxyBlock(),
gtirb.Section(name="test"),
gtirb.Symbol(name="test"),
gtirb.ByteInterval(),
):
with self.subTest(type(node1).__name__):
node2 = gtirb.Node.from_uuid(node1.uuid)
self.assertEqual(node1, node2)
def test_remove_from_cache(self):
ir = gtirb.IR()
m = gtirb.Module()
m.ir = ir
s = gtirb.Section()
s.module = m
self.assertEqual(ir.get_by_uuid(s.uuid), s)
s.module = None
self.assertIsNone(ir.get_by_uuid(s.uuid))
m.sections.discard(s)
self.assertIsNone(ir.get_by_uuid(s.uuid))
def test_from_uuid(self):
for node1 in (
gtirb.IR(),
gtirb.Module(),
gtirb.Block(0, 0),
gtirb.DataObject(0, 0),
gtirb.ProxyBlock(),
gtirb.ImageByteMap(),
gtirb.Section("test", 0, 0),
gtirb.Symbol("test"),
):
with self.subTest(type(node1).__name__):
node2 = gtirb.Node.from_uuid(node1.uuid)
self.assertEqual(node1, node2)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
ir = gtirb.IR()
m = gtirb.Module(
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.RAW,
isa=gtirb.Module.ISA.ValidButUnsupported,
name="name",
preferred_addr=1,
rebase_delta=2,
)
m.ir = ir
s = gtirb.Section(
name="name",
flags=(
gtirb.Section.Flag.Executable,
gtirb.Section.Flag.Readable,
gtirb.Section.Flag.Loaded,
gtirb.Section.Flag.Initialized,
),
)
s.module = m
bi = gtirb.ByteInterval(address=0, size=10, contents=b"abcd")
bi.section = s
cb = gtirb.CodeBlock(size=4, offset=0, decode_mode=1)
cb.byte_interval = bi
db = gtirb.DataBlock(size=6, offset=4)
db.byte_interval = bi
sym = gtirb.Symbol(name="name", payload=cb)
sym.module = m
sac = gtirb.SymAddrConst(0, sym,
{gtirb.SymbolicExpression.Attribute.Part1})
bi.symbolic_expressions[2] = sac
p = gtirb.ProxyBlock()
p.module = m
ir.cfg.add(
gtirb.Edge(
cb,
p,
gtirb.Edge.Label(type=gtirb.Edge.Type.Branch,
conditional=False,
direct=True),
))
ir.cfg.add(gtirb.Edge(p, p))
m.aux_data["key"] = gtirb.AuxData(gtirb.Offset(s, 777), "Offset")
ir.aux_data["key"] = gtirb.AuxData("value", "string")
self.ir = ir
def create_multi_module_ir(self) -> gtirb.IR:
ir = gtirb.IR()
m1 = gtirb.Module(
name="ex",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
)
m1.ir = ir
add_standard_aux_data_tables(m1)
_, bi1 = add_text_section(m1)
add_function(m1, "main", add_code_block(bi1, b"\xC3"))
m2 = gtirb.Module(
name="fun.so",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
)
m2.ir = ir
add_standard_aux_data_tables(m2)
_, bi2 = add_text_section(m2)
add_function(m2, "fun", add_code_block(bi2, b"\xC3"))
return ir
def test_code_blocks(self):
b = gtirb.CodeBlock()
self.assertEquals(b.address, None)
self.assertEquals(b.contents, b"")
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
bi = gtirb.ByteInterval(address=1, contents=b"abcd1234")
b.offset = 2
b.size = 3
b.byte_interval = bi
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), set())
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
s = gtirb.Section()
bi.section = s
m = gtirb.Module()
sym1 = gtirb.Symbol("test", payload=b)
sym2 = gtirb.Symbol("test", payload=123)
sym3 = gtirb.Symbol("test", payload=b)
m.symbols |= {sym1, sym2, sym3}
s.module = m
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), set())
self.assertEquals(set(b.outgoing_edges), set())
i = gtirb.IR()
m.ir = i
e1 = gtirb.Edge(b, gtirb.ProxyBlock())
e2 = gtirb.Edge(gtirb.ProxyBlock(), b)
e3 = gtirb.Edge(gtirb.ProxyBlock(), gtirb.ProxyBlock())
e4 = gtirb.Edge(b, b)
i.cfg |= {e1, e2, e3, e4}
self.assertEquals(b.address, 3)
self.assertEquals(b.contents, b"cd1")
self.assertEquals(set(b.references), {sym1, sym3})
self.assertEquals(set(b.incoming_edges), {e2, e4})
self.assertEquals(set(b.outgoing_edges), {e1, e4})
def create_test_module(
file_format: gtirb.Module.FileFormat,
isa: gtirb.Module.ISA,
binary_type: Iterable[str] = None,
) -> Tuple[gtirb.IR, gtirb.Module]:
"""
Creates a test GTIRB module and returns the IR object and module object.
"""
ir = gtirb.IR()
m = gtirb.Module(isa=isa, file_format=file_format, name="test")
m.ir = ir
add_standard_aux_data_tables(m)
if binary_type:
m.aux_data["binaryType"].data = list(binary_type)
return ir, m
def test_modules(self):
s1 = gtirb.Section(
name="s1", byte_intervals=[gtirb.ByteInterval(address=4, size=4)]
)
s2 = gtirb.Section(
name="s2", byte_intervals=[gtirb.ByteInterval(address=8, size=8)]
)
s3 = gtirb.Section(
name="s3", byte_intervals=[gtirb.ByteInterval(address=100, size=1)]
)
s4 = gtirb.Section(
name="s4", byte_intervals=[gtirb.ByteInterval(size=1000)]
)
m = gtirb.Module(name="M", sections=[s1, s2, s3, s4])
self.assertEquals(set(m.sections_on(3)), set())
self.assertEquals(set(m.sections_on(4)), {s1})
self.assertEquals(set(m.sections_on(7)), {s1})
self.assertEquals(set(m.sections_on(8)), {s2})
self.assertEquals(set(m.sections_on(15)), {s2})
self.assertEquals(set(m.sections_on(16)), set())
self.assertEquals(set(m.sections_on(99)), set())
self.assertEquals(set(m.sections_on(100)), {s3})
self.assertEquals(set(m.sections_on(101)), set())
self.assertEquals(set(m.sections_on(range(0, 100))), {s1, s2})
self.assertEquals(set(m.sections_on(range(0, 101))), {s1, s2, s3})
self.assertEquals(set(m.sections_on(range(0, 102))), {s1, s2, s3})
self.assertEquals(set(m.sections_on(range(7, 7 + 4))), {s1, s2})
self.assertEquals(set(m.sections_on(range(8, 8 + 4))), {s2})
self.assertEquals(set(m.sections_on(range(17, 17 + 80))), set())
self.assertEquals(set(m.sections_at(3)), set())
self.assertEquals(set(m.sections_at(4)), {s1})
self.assertEquals(set(m.sections_at(5)), set())
self.assertEquals(set(m.sections_at(7)), set())
self.assertEquals(set(m.sections_at(8)), {s2})
self.assertEquals(set(m.sections_at(9)), set())
self.assertEquals(set(m.sections_at(99)), set())
self.assertEquals(set(m.sections_at(100)), {s3})
self.assertEquals(set(m.sections_at(101)), set())
self.assertEquals(set(m.sections_at(range(0, 100))), {s1, s2})
self.assertEquals(set(m.sections_at(range(0, 101))), {s1, s2, s3})
self.assertEquals(set(m.sections_at(range(5, 10))), {s2})
self.assertEquals(set(m.sections_at(range(95, 105))), {s3})
def test_byte_intervals_on(self, scope):
ir = gtirb.IR()
m = gtirb.Module(name="test", ir=ir)
s = gtirb.Section(module=m)
search_in = scope.select(ir, m, s, None)
bi1 = gtirb.ByteInterval(address=0x1000, size=4, section=s)
bi2 = gtirb.ByteInterval(address=0x1004, size=4, section=s)
found = set(search_in.byte_intervals_on(0x1000))
self.assertEqual(found, {bi1})
found = set(search_in.byte_intervals_on(0x1001))
self.assertEqual(found, {bi1})
found = set(search_in.byte_intervals_on(range(0x1000, 0x1008)))
self.assertEqual(found, {bi1, bi2})
found = set(search_in.byte_intervals_on(range(0x1000, 0x1008, 16)))
self.assertEqual(found, {bi1, bi2})
# Change the address to verify we update the index
bi2.address = 0x2000
found = set(search_in.byte_intervals_on(0x1005))
self.assertEqual(found, set())
found = set(search_in.byte_intervals_on(0x2001))
self.assertEqual(found, {bi2})
# Discard the interval to verify we update the index
bi2.section = None
found = set(search_in.byte_intervals_on(0x2001))
self.assertEqual(found, set())
# Now add it back to verify we update the index
s.byte_intervals.add(bi2)
found = set(search_in.byte_intervals_on(0x2001))
self.assertEqual(found, {bi2})
def test_get_by_uuid(self):
ir1 = gtirb.IR()
ir2 = gtirb.IR()
# test nodes from one IR don't pollute the cache of other IRs
self.assertIsNone(ir1.get_by_uuid(ir2.uuid))
self.assertIsNone(ir2.get_by_uuid(ir1.uuid))
self.assertEqual(ir1.get_by_uuid(ir1.uuid), ir1)
self.assertEqual(ir2.get_by_uuid(ir2.uuid), ir2)
m = gtirb.Module()
m.ir = ir1
s = gtirb.Section()
s.module = m
bi = gtirb.ByteInterval()
bi.section = s
b = gtirb.CodeBlock()
b.byte_interval = bi
sym = gtirb.Symbol("test")
sym.module = m
# test all nodes are lookupable by any other node type
self.assertEqual(ir1.get_by_uuid(m.uuid), m)
self.assertEqual(ir1.get_by_uuid(s.uuid), s)
self.assertEqual(ir1.get_by_uuid(bi.uuid), bi)
self.assertEqual(ir1.get_by_uuid(b.uuid), b)
self.assertEqual(ir1.get_by_uuid(sym.uuid), sym)
self.assertEqual(m.ir.get_by_uuid(m.uuid), m)
self.assertEqual(m.ir.get_by_uuid(s.uuid), s)
self.assertEqual(m.ir.get_by_uuid(bi.uuid), bi)
self.assertEqual(m.ir.get_by_uuid(b.uuid), b)
self.assertEqual(m.ir.get_by_uuid(sym.uuid), sym)
self.assertEqual(s.ir.get_by_uuid(m.uuid), m)
self.assertEqual(s.ir.get_by_uuid(s.uuid), s)
self.assertEqual(s.ir.get_by_uuid(bi.uuid), bi)
self.assertEqual(s.ir.get_by_uuid(b.uuid), b)
self.assertEqual(s.ir.get_by_uuid(sym.uuid), sym)
self.assertEqual(bi.ir.get_by_uuid(m.uuid), m)
self.assertEqual(bi.ir.get_by_uuid(s.uuid), s)
self.assertEqual(bi.ir.get_by_uuid(bi.uuid), bi)
self.assertEqual(bi.ir.get_by_uuid(b.uuid), b)
self.assertEqual(bi.ir.get_by_uuid(sym.uuid), sym)
self.assertEqual(b.ir.get_by_uuid(m.uuid), m)
self.assertEqual(b.ir.get_by_uuid(s.uuid), s)
self.assertEqual(b.ir.get_by_uuid(bi.uuid), bi)
self.assertEqual(b.ir.get_by_uuid(b.uuid), b)
self.assertEqual(b.ir.get_by_uuid(sym.uuid), sym)
self.assertEqual(sym.ir.get_by_uuid(m.uuid), m)
self.assertEqual(sym.ir.get_by_uuid(s.uuid), s)
self.assertEqual(sym.ir.get_by_uuid(bi.uuid), bi)
self.assertEqual(sym.ir.get_by_uuid(b.uuid), b)
self.assertEqual(sym.ir.get_by_uuid(sym.uuid), sym)
# test removing a node removes all children as well
bi.section = None
self.assertEqual(ir1.get_by_uuid(m.uuid), m)
self.assertEqual(ir1.get_by_uuid(s.uuid), s)
self.assertIsNone(ir1.get_by_uuid(bi.uuid))
self.assertIsNone(ir1.get_by_uuid(b.uuid))
self.assertEqual(ir1.get_by_uuid(sym.uuid), sym)
bi.section = s
self.assertEqual(ir1.get_by_uuid(m.uuid), m)
self.assertEqual(ir1.get_by_uuid(s.uuid), s)
self.assertEqual(ir1.get_by_uuid(bi.uuid), bi)
self.assertEqual(ir1.get_by_uuid(b.uuid), b)
self.assertEqual(ir1.get_by_uuid(sym.uuid), sym)
def test_module(self):
# TODO: expand this
node = gtirb.Module(name="M")
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
def test_module(self):
id1 = uuid.uuid4()
id2 = uuid.uuid4()
id3 = uuid.uuid4()
id4 = uuid.uuid4()
id5 = uuid.uuid4()
id6 = uuid.uuid4()
id7 = uuid.uuid4()
id8 = uuid.uuid4()
m1 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertTrue(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("other_value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertTrue(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="other_binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.PE,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.ARM,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="other_name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=5,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=5,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=2, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id4), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id4), ),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym11", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(gtirb.Symbol(name="sym1", uuid=id5), ),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect22", uuid=id8),
),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(gtirb.Section(name="sect2", uuid=id8), ),
uuid=id1,
)
self.assertFalse(m1.deep_eq(m2))
m2 = gtirb.Module(
aux_data={"key": gtirb.AuxData("value", "string")},
binary_path="binary_path",
file_format=gtirb.Module.FileFormat.ELF,
isa=gtirb.Module.ISA.X64,
name="name",
preferred_addr=1,
rebase_delta=2,
entry_point=gtirb.CodeBlock(size=1, uuid=id2),
proxies=(gtirb.ProxyBlock(uuid=id3), gtirb.ProxyBlock(uuid=id4)),
symbols=(
gtirb.Symbol(name="sym1", uuid=id5),
gtirb.Symbol(name="sym2", uuid=id6),
),
sections=(
gtirb.Section(name="sect1", uuid=id7),
gtirb.Section(name="sect2", uuid=id8),
),
uuid=id2,
)
self.assertFalse(m1.deep_eq(m2))
def test_ir(self):
id1 = uuid.uuid4()
id2 = uuid.uuid4()
id3 = uuid.uuid4()
id4 = uuid.uuid4()
id5 = uuid.uuid4()
ir1 = gtirb.IR(
modules=(
gtirb.Module(name="m1", uuid=id2),
gtirb.Module(name="m2", uuid=id3),
),
aux_data={"key": gtirb.AuxData("value", "string")},
cfg=(
gtirb.Edge(
gtirb.CodeBlock(size=1, uuid=id4),
gtirb.CodeBlock(size=2, uuid=id4),
None,
),
gtirb.Edge(
gtirb.CodeBlock(size=3, uuid=id4),
gtirb.CodeBlock(size=4, uuid=id4),
None,
),
),
version=1,
uuid=id1,
)
ir2 = gtirb.IR(
modules=(
gtirb.Module(name="m1", uuid=id2),
gtirb.Module(name="m2", uuid=id3),
),
aux_data={"key": gtirb.AuxData("value", "string")},
cfg=(
gtirb.Edge(
gtirb.CodeBlock(size=1, uuid=id4),
gtirb.CodeBlock(size=2, uuid=id4),
None,
),
gtirb.Edge(
gtirb.CodeBlock(size=3, uuid=id4),
gtirb.CodeBlock(size=4, uuid=id4),
None,
),
),
version=1,
uuid=id1,
)
self.assertTrue(ir1.deep_eq(ir2))
ir2 = gtirb.IR(
modules=(
gtirb.Module(name="m1", uuid=id2),
gtirb.Module(name="m2", uuid=id3),
),
aux_data={"key": gtirb.AuxData("other_value", "string")},
cfg=(
gtirb.Edge(
gtirb.CodeBlock(size=1, uuid=id4),
gtirb.CodeBlock(size=2, uuid=id4),
None,
),
gtirb.Edge(
gtirb.CodeBlock(size=3, uuid=id4),
gtirb.CodeBlock(size=4, uuid=id4),
None,
),
),
version=1,
uuid=id1,
)
self.assertTrue(ir1.deep_eq(ir2))
ir2 = gtirb.IR(
modules=(
gtirb.Module(name="m11", uuid=id2),
gtirb.Module(name="m2", uuid=id3),
),
aux_data={"key": gtirb.AuxData("value", "string")},
cfg=(
gtirb.Edge(
gtirb.CodeBlock(size=1, uuid=id4),
gtirb.CodeBlock(size=2, uuid=id4),
None,
),
gtirb.Edge(
gtirb.CodeBlock(size=3, uuid=id4),
gtirb.CodeBlock(size=4, uuid=id4),
None,
),
),
version=1,
uuid=id1,
)
self.assertFalse(ir1.deep_eq(ir2))
ir2 = gtirb.IR(
modules=(gtirb.Module(name="m1", uuid=id2), ),
aux_data={"key": gtirb.AuxData("value", "string")},
cfg=(
gtirb.Edge(
gtirb.CodeBlock(size=1, uuid=id4),
gtirb.CodeBlock(size=2, uuid=id4),
None,
),
gtirb.Edge(
gtirb.CodeBlock(size=3, uuid=id4),
gtirb.CodeBlock(size=4, uuid=id4),
None,
),
),
version=1,
uuid=id1,
)
self.assertFalse(ir1.deep_eq(ir2))
ir2 = gtirb.IR(
modules=(
gtirb.Module(name="m1", uuid=id2),
gtirb.Module(name="m2", uuid=id3),
),
aux_data={"key": gtirb.AuxData("value", "string")},
cfg=(
gtirb.Edge(
gtirb.CodeBlock(size=55, uuid=id4),
gtirb.CodeBlock(size=2, uuid=id4),
None,
),
gtirb.Edge(
gtirb.CodeBlock(size=3, uuid=id4),
gtirb.CodeBlock(size=4, uuid=id4),
None,
),
),
version=1,
uuid=id1,
)
self.assertFalse(ir1.deep_eq(ir2))
ir2 = gtirb.IR(
modules=(
gtirb.Module(name="m1", uuid=id2),
gtirb.Module(name="m2", uuid=id3),
),
aux_data={"key": gtirb.AuxData("value", "string")},
cfg=(gtirb.Edge(
gtirb.CodeBlock(size=3, uuid=id4),
gtirb.CodeBlock(size=4, uuid=id4),
None,
), ),
version=1,
uuid=id1,
)
self.assertFalse(ir1.deep_eq(ir2))
ir2 = gtirb.IR(
modules=(
gtirb.Module(name="m1", uuid=id2),
gtirb.Module(name="m2", uuid=id3),
),
aux_data={"key": gtirb.AuxData("value", "string")},
cfg=(
gtirb.Edge(
gtirb.CodeBlock(size=1, uuid=id4),
gtirb.CodeBlock(size=2, uuid=id4),
None,
),
gtirb.Edge(
gtirb.CodeBlock(size=3, uuid=id4),
gtirb.CodeBlock(size=4, uuid=id4),
None,
),
),
version=5,
uuid=id1,
)
self.assertFalse(ir1.deep_eq(ir2))
ir2 = gtirb.IR(
modules=(
gtirb.Module(name="m1", uuid=id2),
gtirb.Module(name="m2", uuid=id3),
),
aux_data={"key": gtirb.AuxData("value", "string")},
cfg=(
gtirb.Edge(
gtirb.CodeBlock(size=1, uuid=id4),
gtirb.CodeBlock(size=2, uuid=id4),
None,
),
gtirb.Edge(
gtirb.CodeBlock(size=3, uuid=id4),
gtirb.CodeBlock(size=4, uuid=id4),
None,
),
),
version=1,
uuid=id5,
)
self.assertFalse(ir1.deep_eq(ir2))
