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_data_block(self):
id1 = uuid.uuid4()
id2 = uuid.uuid4()
b1 = gtirb.DataBlock(size=1, offset=3, uuid=id1)
b2 = gtirb.DataBlock(size=1, offset=3, uuid=id1)
self.assertTrue(b1.deep_eq(b2))
b2 = gtirb.DataBlock(size=5, offset=3, uuid=id1)
self.assertFalse(b1.deep_eq(b2))
b2 = gtirb.DataBlock(size=1, offset=5, uuid=id1)
self.assertFalse(b1.deep_eq(b2))
b2 = gtirb.DataBlock(size=1, offset=3, uuid=id2)
self.assertFalse(b1.deep_eq(b2))
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_from_uuid_typed(self):
nodes = (
gtirb.IR(),
gtirb.Module(),
gtirb.CodeBlock(size=0),
gtirb.DataBlock(size=0),
gtirb.ProxyBlock(),
gtirb.Section(name="test"),
gtirb.Symbol(name="test"),
gtirb.ByteInterval(),
)
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_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_byte_blocks(self):
s = gtirb.Section()
bi1 = gtirb.ByteInterval(size=4, section=s)
bi1_code_block = gtirb.CodeBlock(offset=0, size=1, byte_interval=bi1)
bi1_data_block = gtirb.DataBlock(offset=1, size=1, byte_interval=bi1)
bi2 = gtirb.ByteInterval(size=4, section=s)
bi2_code_block = gtirb.CodeBlock(offset=0, size=1, byte_interval=bi2)
bi2_data_block = gtirb.DataBlock(offset=1, size=1, byte_interval=bi2)
self.assertEqual(
set(s.byte_blocks),
{bi1_code_block, bi1_data_block, bi2_code_block, bi2_data_block},
)
self.assertEqual(set(s.code_blocks), {bi1_code_block, bi2_code_block})
self.assertEqual(set(s.data_blocks), {bi1_data_block, bi2_data_block})
def test_data_blocks_at(self, scope):
"Test that data_blocks_at only gives back DataBlocks"
ir, m, s, bi = create_interval_etc(address=0x1000, size=4)
search_in = scope.select(ir, m, s, bi)
code_block = gtirb.CodeBlock(offset=0, size=1, byte_interval=bi)
data_block = gtirb.DataBlock(offset=0, size=1, byte_interval=bi)
found = set(search_in.data_blocks_at(0x1000))
self.assertEqual(found, {data_block})
def test_byte_interval(self):
node = gtirb.ByteInterval(
address=0x123,
initialized_size=456,
size=789,
contents=b"abc",
blocks=(gtirb.DataBlock(size=0),),
symbolic_expressions={
1: gtirb.SymAddrConst(offset=1, symbol=gtirb.Symbol("test"))
},
)
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
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 __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 test_data_object(self):
node = gtirb.DataBlock(offset=123, size=456)
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
def test_byte_intervals(self):
id1 = uuid.uuid4()
id2 = uuid.uuid4()
id3 = uuid.uuid4()
id4 = uuid.uuid4()
id5 = uuid.uuid4()
id6 = uuid.uuid4()
b1 = gtirb.ByteInterval(
address=1,
contents=b"abcd",
size=4,
initialized_size=4,
blocks=(
gtirb.DataBlock(size=1, offset=3, uuid=id2),
gtirb.CodeBlock(size=1, decode_mode=2, offset=3, uuid=id3),
),
symbolic_expressions={
2:
gtirb.SymAddrConst(
3, gtirb.Symbol(name="name1", payload=4, uuid=id4)),
3:
gtirb.SymStackConst(
4, gtirb.Symbol(name="name2", payload=8, uuid=id5)),
},
uuid=id1,
)
b2 = gtirb.ByteInterval(
address=1,
contents=b"abcd",
size=4,
initialized_size=4,
blocks=(
gtirb.DataBlock(size=1, offset=3, uuid=id2),
gtirb.CodeBlock(size=1, decode_mode=2, offset=3, uuid=id3),
),
symbolic_expressions={
2:
gtirb.SymAddrConst(
3, gtirb.Symbol(name="name1", payload=4, uuid=id4)),
3:
gtirb.SymStackConst(
4, gtirb.Symbol(name="name2", payload=8, uuid=id5)),
},
uuid=id1,
)
self.assertTrue(b1.deep_eq(b2))
b2 = gtirb.ByteInterval(
address=None,
contents=b"abcd",
size=4,
initialized_size=4,
blocks=(
gtirb.DataBlock(size=1, offset=3, uuid=id2),
gtirb.CodeBlock(size=1, decode_mode=2, offset=3, uuid=id3),
),
symbolic_expressions={
2:
gtirb.SymAddrConst(
3, gtirb.Symbol(name="name1", payload=4, uuid=id4)),
3:
gtirb.SymStackConst(
4, gtirb.Symbol(name="name2", payload=8, uuid=id5)),
},
uuid=id1,
)
self.assertFalse(b1.deep_eq(b2))
b2 = gtirb.ByteInterval(
address=1,
contents=b"1234",
size=4,
initialized_size=4,
blocks=(
gtirb.DataBlock(size=1, offset=3, uuid=id2),
gtirb.CodeBlock(size=1, decode_mode=2, offset=3, uuid=id3),
),
symbolic_expressions={
2:
gtirb.SymAddrConst(
3, gtirb.Symbol(name="name1", payload=4, uuid=id4)),
3:
gtirb.SymStackConst(
4, gtirb.Symbol(name="name2", payload=8, uuid=id5)),
},
uuid=id1,
)
self.assertFalse(b1.deep_eq(b2))
b2 = gtirb.ByteInterval(
address=1,
contents=b"abcd",
size=8,
initialized_size=4,
blocks=(
gtirb.DataBlock(size=1, offset=3, uuid=id2),
gtirb.CodeBlock(size=1, decode_mode=2, offset=3, uuid=id3),
),
symbolic_expressions={
2:
gtirb.SymAddrConst(
3, gtirb.Symbol(name="name1", payload=4, uuid=id4)),
3:
gtirb.SymStackConst(
4, gtirb.Symbol(name="name2", payload=8, uuid=id5)),
},
uuid=id1,
)
self.assertFalse(b1.deep_eq(b2))
b2 = gtirb.ByteInterval(
address=1,
contents=b"abcd",
size=4,
initialized_size=0,
blocks=(
gtirb.DataBlock(size=1, offset=3, uuid=id2),
gtirb.CodeBlock(size=1, decode_mode=2, offset=3, uuid=id3),
),
symbolic_expressions={
2:
gtirb.SymAddrConst(
3, gtirb.Symbol(name="name1", payload=4, uuid=id4)),
3:
gtirb.SymStackConst(
4, gtirb.Symbol(name="name2", payload=8, uuid=id5)),
},
uuid=id1,
)
self.assertFalse(b1.deep_eq(b2))
b2 = gtirb.ByteInterval(
address=1,
contents=b"abcd",
size=4,
initialized_size=4,
blocks=(
gtirb.DataBlock(size=1, offset=3, uuid=id2),
gtirb.CodeBlock(size=1, decode_mode=5, offset=3, uuid=id3),
),
symbolic_expressions={
2:
gtirb.SymAddrConst(
3, gtirb.Symbol(name="name1", payload=4, uuid=id4)),
3:
gtirb.SymStackConst(
4, gtirb.Symbol(name="name2", payload=8, uuid=id5)),
},
uuid=id1,
)
self.assertFalse(b1.deep_eq(b2))
b2 = gtirb.ByteInterval(
address=1,
contents=b"abcd",
size=4,
initialized_size=4,
blocks=(gtirb.CodeBlock(size=1, decode_mode=2, offset=3,
uuid=id3), ),
symbolic_expressions={
2:
gtirb.SymAddrConst(
3, gtirb.Symbol(name="name1", payload=4, uuid=id4)),
3:
gtirb.SymStackConst(
4, gtirb.Symbol(name="name2", payload=8, uuid=id5)),
},
uuid=id1,
)
self.assertFalse(b1.deep_eq(b2))
b2 = gtirb.ByteInterval(
address=1,
contents=b"abcd",
size=4,
initialized_size=4,
blocks=(
gtirb.DataBlock(size=1, offset=3, uuid=id2),
gtirb.CodeBlock(size=1, decode_mode=2, offset=3, uuid=id3),
),
symbolic_expressions={
2:
gtirb.SymAddrConst(
6, gtirb.Symbol(name="name1", payload=4, uuid=id4)),
3:
gtirb.SymStackConst(
4, gtirb.Symbol(name="name2", payload=8, uuid=id5)),
},
uuid=id1,
)
self.assertFalse(b1.deep_eq(b2))
b2 = gtirb.ByteInterval(
address=1,
contents=b"abcd",
size=4,
initialized_size=4,
blocks=(
gtirb.DataBlock(size=1, offset=3, uuid=id2),
gtirb.CodeBlock(size=1, decode_mode=2, offset=3, uuid=id3),
),
symbolic_expressions={
2:
gtirb.SymAddrConst(
3, gtirb.Symbol(name="name1", payload=4, uuid=id4))
},
uuid=id1,
)
self.assertFalse(b1.deep_eq(b2))
b2 = gtirb.ByteInterval(
address=1,
contents=b"abcd",
size=4,
initialized_size=4,
blocks=(
gtirb.DataBlock(size=1, offset=3, uuid=id2),
gtirb.CodeBlock(size=1, decode_mode=2, offset=3, uuid=id3),
),
symbolic_expressions={
7:
gtirb.SymAddrConst(
3, gtirb.Symbol(name="name1", payload=4, uuid=id4)),
8:
gtirb.SymStackConst(
4, gtirb.Symbol(name="name2", payload=8, uuid=id5)),
},
uuid=id1,
)
self.assertFalse(b1.deep_eq(b2))
b2 = gtirb.ByteInterval(
address=1,
contents=b"abcd",
size=4,
initialized_size=4,
blocks=(
gtirb.DataBlock(size=1, offset=3, uuid=id2),
gtirb.CodeBlock(size=1, decode_mode=2, offset=3, uuid=id3),
),
symbolic_expressions={
2:
gtirb.SymAddrConst(
3, gtirb.Symbol(name="name1", payload=4, uuid=id4)),
3:
gtirb.SymStackConst(
4, gtirb.Symbol(name="name2", payload=8, uuid=id5)),
},
uuid=id6,
)
self.assertFalse(b1.deep_eq(b2))
