def build_gtirb():
(ir, module) = gth.create_test_module(
gtirb.Module.FileFormat.ELF, gtirb.Module.ISA.X64,
)
(text_section, text_bi) = gth.add_text_section(module)
proxy_a = gth.add_proxy_block(module)
symbol_a = gth.add_symbol(module, "a", proxy_a)
se_a = gtirb.SymAddrConst(
0, symbol_a, {gtirb.SymbolicExpression.Attribute.PltRef}
)
proxy_b = gth.add_proxy_block(module)
symbol_b = gth.add_symbol(module, "b", proxy_b)
se_b = gtirb.SymAddrConst(
0, symbol_b, {gtirb.SymbolicExpression.Attribute.PltRef}
)
# For the following code:
# e8 00 00 00 00 callq a@plt
# e8 00 00 00 00 callq b@plt
# 48 31 c0 xor %rax,%rax
# 48 c7 c0 3c 00 00 00 mov $0x3c,%rax
# 48 31 ff xor %rdi,%rdi
# 0f 05 syscall
cb = gth.add_code_block(
text_bi,
b"\xe8\x00\x00\x00\x00"
b"\xe8\x00\x00\x00\x00"
b"\x48\x31\xc0"
b"\x48\xc7\xc0\x3c\x00\x00\x00"
b"\x48\x31\xff"
b"\x0f\x05",
{1: se_a, 6: se_b},
)
symbol_start = gth.add_symbol(module, "_start", cb)
module.aux_data["libraries"].data.extend(["libmya.so", "libmyb.so"])
module.aux_data["elfSymbolInfo"].data[symbol_start.uuid] = (
0,
"FUNC",
"GLOBAL",
"DEFAULT",
0,
)
module.aux_data["elfSymbolInfo"].data[symbol_a.uuid] = (
0,
"FUNC",
"GLOBAL",
"DEFAULT",
0,
)
module.aux_data["elfSymbolInfo"].data[symbol_b.uuid] = (
0,
"FUNC",
"GLOBAL",
"DEFAULT",
0,
)
return ir
def test_sym_expr(self):
node = gtirb.SymAddrConst(
offset=123,
symbol=gtirb.Symbol(name="symbol", payload=gtirb.ProxyBlock()),
)
string = repr(node)
new_node = eval(string)
self.assertEqual(node.offset, new_node.offset)
self.assertTrue(node.symbol.deep_eq(new_node.symbol))
node = gtirb.SymStackConst(
offset=123,
symbol=gtirb.Symbol(name="symbol", payload=gtirb.ProxyBlock()),
)
string = repr(node)
new_node = eval(string)
self.assertEqual(node.offset, new_node.offset)
self.assertTrue(node.symbol.deep_eq(new_node.symbol))
node = gtirb.SymAddrAddr(
offset=123,
scale=2,
symbol1=gtirb.Symbol(name="symbol1", payload=gtirb.ProxyBlock()),
symbol2=gtirb.Symbol(name="symbol2", payload=gtirb.ProxyBlock()),
)
string = repr(node)
new_node = eval(string)
self.assertEqual(node.offset, new_node.offset)
self.assertEqual(node.scale, new_node.scale)
self.assertTrue(node.symbol1.deep_eq(new_node.symbol1))
self.assertTrue(node.symbol2.deep_eq(new_node.symbol2))
def test_symbolic_expressions_at(self, scope):
ir, m, s, bi = create_interval_etc(address=0x1000, size=5)
search_in = scope.select(ir, m, s, bi)
sym = gtirb.Symbol(name="hello")
expr = gtirb.SymAddrConst(0, sym)
bi.symbolic_expressions[1] = expr
bi.symbolic_expressions[2] = expr
bi.symbolic_expressions[3] = expr
bi.symbolic_expressions[4] = expr
found = set(search_in.symbolic_expressions_at(0x1001))
self.assertEqual(found, {(bi, 1, expr)})
found = set(search_in.symbolic_expressions_at(range(0x1000, 0x1004)))
self.assertEqual(found, {(bi, 1, expr), (bi, 2, expr), (bi, 3, expr)})
found = set(
search_in.symbolic_expressions_at(range(0x1000, 0x1004, 2))
)
self.assertEqual(found, {(bi, 2, expr)})
# Now just verify that the index updates correctly when deleting
del bi.symbolic_expressions[1]
found = set(search_in.symbolic_expressions_at(0x1001))
self.assertEqual(found, set())
def test_moffset_mov_ia32_compat(self):
ir, m = create_test_module(
gtirb.Module.FileFormat.PE, gtirb.Module.ISA.IA32
)
s, bi = add_text_section(m, 0x1000)
hello_expr = gtirb.SymAddrConst(0, add_symbol(m, "hello"))
# mov al, byte ptr [hello]
add_code_block(bi, b"\xA0\x00\x00\x00\x00", {0: hello_expr})
# mov ax, word ptr [hello]
add_code_block(bi, b"\x66\xA1\x00\x00\x00\x00", {0: hello_expr})
# mov eax, dword ptr [hello]
add_code_block(bi, b"\xA1\x00\x00\x00\x00", {0: hello_expr})
# mov byte ptr [hello], al
add_code_block(bi, b"\xA2\x00\x00\x00\x00", {0: hello_expr})
# mov word ptr [hello], ax
add_code_block(bi, b"\x66\xA3\x00\x00\x00\x00", {0: hello_expr})
# mov dword ptr [hello], eax
add_code_block(bi, b"\xA3\x00\x00\x00\x00", {0: hello_expr})
asm, output = run_asm_pprinter_with_outputput(ir)
self.assertIn(self.COMPAT_WARNING_MESSAGE, output)
self.assertEqual(output.count(self.COMPAT_WARNING_MESSAGE), 1)
self.assertContains(
asm_lines(asm),
(
"mov AL,BYTE PTR [hello]",
"mov AX,WORD PTR [hello]",
"mov EAX,DWORD PTR [hello]",
"mov BYTE PTR [hello],AL",
"mov WORD PTR [hello],AX",
"mov DWORD PTR [hello],EAX",
),
)
def test_nonmoffset_mov(self):
ir, m = create_test_module(
gtirb.Module.FileFormat.PE, gtirb.Module.ISA.IA32
)
s, bi = add_text_section(m, 0x1000)
hello_expr = gtirb.SymAddrConst(0, add_symbol(m, "hello"))
add_code_block(
bi,
# mov edi, hello
b"\x8B\x3D\x00\x00\x00\x00",
# wrong symbolic offset
{0: hello_expr},
)
add_code_block(
bi,
# mov edi, hello
b"\x8B\x3D\x00\x00\x00\x00",
# correct symbolic offset
{2: hello_expr},
)
asm, output = run_asm_pprinter_with_outputput(ir)
self.assertNotIn(self.COMPAT_WARNING_MESSAGE, output)
self.assertContains(
asm_lines(asm),
("mov EDI,DWORD PTR [0]", "mov EDI,DWORD PTR [hello]"),
)
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_byte_intervals(self):
s = gtirb.Symbol(name="test")
se1 = gtirb.SymAddrConst(0, s)
se3 = gtirb.SymAddrAddr(0, 1, s, s)
bi = gtirb.ByteInterval(address=10,
size=5,
symbolic_expressions={
0: se1,
4: se3
})
self.assertEqual(set(bi.symbolic_expressions_at(9)), set())
self.assertEqual(set(bi.symbolic_expressions_at(10)), {(bi, 0, se1)})
self.assertEqual(set(bi.symbolic_expressions_at(11)), set())
self.assertEqual(set(bi.symbolic_expressions_at(13)), set())
self.assertEqual(set(bi.symbolic_expressions_at(14)), {(bi, 4, se3)})
self.assertEqual(set(bi.symbolic_expressions_at(15)), set())
self.assertEqual(set(bi.symbolic_expressions_at(range(0, 9))), set())
self.assertEqual(set(bi.symbolic_expressions_at(range(11, 14))), set())
self.assertEqual(set(bi.symbolic_expressions_at(range(20, 90))), set())
self.assertEqual(
set(bi.symbolic_expressions_at(range(0, 90))),
{(bi, 0, se1), (bi, 4, se3)},
)
self.assertEqual(
set(bi.symbolic_expressions_at(range(10, 15))),
{(bi, 0, se1), (bi, 4, se3)},
)
self.assertEqual(set(bi.symbolic_expressions_at(range(11, 18))),
{(bi, 4, se3)})
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_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 __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_sym_exprs(self):
node = gtirb.SymAddrConst(
offset=123,
symbol=gtirb.Symbol(name="symbol", payload=gtirb.ProxyBlock()),
)
self.assertEqual({x.name for x in node.symbols}, {"symbol"})
node = gtirb.SymAddrAddr(
offset=123,
scale=2,
symbol1=gtirb.Symbol(name="symbol1", payload=gtirb.ProxyBlock()),
symbol2=gtirb.Symbol(name="symbol2", payload=gtirb.ProxyBlock()),
)
self.assertEqual({x.name
for x in node.symbols}, {"symbol1", "symbol2"})
def test_moffset_mov_x64_correct(self):
ir, m = create_test_module(
gtirb.Module.FileFormat.PE, gtirb.Module.ISA.X64
)
s, bi = add_text_section(m, 0x1000)
hello_expr = gtirb.SymAddrConst(0, add_symbol(m, "hello"))
# mov rax, qword ptr [hello]
add_code_block(
bi, b"\x48\xA1\x00\x00\x00\x00\x00\x00\x00\x00", {2: hello_expr}
)
# mov qword ptr [hello], rax
add_code_block(
bi, b"\x48\xA3\x00\x00\x00\x00\x00\x00\x00\x00", {2: hello_expr}
)
asm, output = run_asm_pprinter_with_outputput(ir)
self.assertNotIn(self.COMPAT_WARNING_MESSAGE, output)
self.assertContains(
asm_lines(asm),
("mov RAX,QWORD PTR [hello]", "mov QWORD PTR [hello],RAX",),
)
def test_sym_expr(self):
node = gtirb.SymAddrConst(
offset=123,
symbol=gtirb.Symbol(name="symbol", payload=gtirb.ProxyBlock()),
attributes=set(),
)
string = repr(node)
new_node = eval(string)
self.assertTrue(node.deep_eq(new_node))
node = gtirb.SymAddrAddr(
offset=123,
scale=2,
symbol1=gtirb.Symbol(name="symbol1", payload=gtirb.ProxyBlock()),
symbol2=gtirb.Symbol(name="symbol2", payload=gtirb.ProxyBlock()),
attributes={
gtirb.SymbolicExpression.Attribute.Adjusted,
gtirb.SymbolicExpression.Attribute.Part0,
},
)
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))
def test_sym_exprs(self):
id1 = uuid.uuid4()
id2 = uuid.uuid4()
# SymAddrConst
s1 = gtirb.SymAddrConst(offset=1,
symbol=gtirb.Symbol(name="name",
payload=None,
uuid=id1))
s2 = gtirb.SymAddrConst(offset=1,
symbol=gtirb.Symbol(name="name",
payload=None,
uuid=id1))
self.assertTrue(s1.deep_eq(s2))
s1 = gtirb.SymAddrConst(offset=1,
symbol=gtirb.Symbol(name="name",
payload=None,
uuid=id1))
s2 = gtirb.SymAddrConst(offset=2,
symbol=gtirb.Symbol(name="name",
payload=None,
uuid=id1))
self.assertFalse(s1.deep_eq(s2))
s1 = gtirb.SymAddrConst(offset=1,
symbol=gtirb.Symbol(name="name1",
payload=None,
uuid=id1))
s2 = gtirb.SymAddrConst(offset=1,
symbol=gtirb.Symbol(name="name2",
payload=None,
uuid=id1))
self.assertFalse(s1.deep_eq(s2))
# SymStackConst
s1 = gtirb.SymStackConst(offset=1,
symbol=gtirb.Symbol(name="name",
payload=None,
uuid=id1))
s2 = gtirb.SymStackConst(offset=1,
symbol=gtirb.Symbol(name="name",
payload=None,
uuid=id1))
self.assertTrue(s1.deep_eq(s2))
s1 = gtirb.SymStackConst(offset=1,
symbol=gtirb.Symbol(name="name",
payload=None,
uuid=id1))
s2 = gtirb.SymStackConst(offset=2,
symbol=gtirb.Symbol(name="name",
payload=None,
uuid=id1))
self.assertFalse(s1.deep_eq(s2))
s1 = gtirb.SymStackConst(offset=1,
symbol=gtirb.Symbol(name="name1",
payload=None,
uuid=id1))
s2 = gtirb.SymStackConst(offset=1,
symbol=gtirb.Symbol(name="name2",
payload=None,
uuid=id1))
self.assertFalse(s1.deep_eq(s2))
# SymAddrAddr
s1 = gtirb.SymAddrAddr(
offset=1,
scale=2,
symbol1=gtirb.Symbol(name="name1", payload=None, uuid=id1),
symbol2=gtirb.Symbol(name="name2", payload=None, uuid=id2),
)
s2 = gtirb.SymAddrAddr(
offset=1,
scale=2,
symbol1=gtirb.Symbol(name="name1", payload=None, uuid=id1),
symbol2=gtirb.Symbol(name="name2", payload=None, uuid=id2),
)
self.assertTrue(s1.deep_eq(s2))
s1 = gtirb.SymAddrAddr(
offset=1,
scale=2,
symbol1=gtirb.Symbol(name="name1", payload=None, uuid=id1),
symbol2=gtirb.Symbol(name="name2", payload=None, uuid=id2),
)
s2 = gtirb.SymAddrAddr(
offset=2,
scale=2,
symbol1=gtirb.Symbol(name="name1", payload=None, uuid=id1),
symbol2=gtirb.Symbol(name="name2", payload=None, uuid=id2),
)
self.assertFalse(s1.deep_eq(s2))
s1 = gtirb.SymAddrAddr(
offset=1,
scale=2,
symbol1=gtirb.Symbol(name="name1", payload=None, uuid=id1),
symbol2=gtirb.Symbol(name="name2", payload=None, uuid=id2),
)
s2 = gtirb.SymAddrAddr(
offset=1,
scale=4,
symbol1=gtirb.Symbol(name="name1", payload=None, uuid=id1),
symbol2=gtirb.Symbol(name="name2", payload=None, uuid=id2),
)
self.assertFalse(s1.deep_eq(s2))
s1 = gtirb.SymAddrAddr(
offset=1,
scale=2,
symbol1=gtirb.Symbol(name="name1", payload=None, uuid=id1),
symbol2=gtirb.Symbol(name="name2", payload=None, uuid=id2),
)
s2 = gtirb.SymAddrAddr(
offset=1,
scale=2,
symbol1=gtirb.Symbol(name="name3", payload=None, uuid=id1),
symbol2=gtirb.Symbol(name="name2", payload=None, uuid=id2),
)
self.assertFalse(s1.deep_eq(s2))
s1 = gtirb.SymAddrAddr(
offset=1,
scale=2,
symbol1=gtirb.Symbol(name="name1", payload=None, uuid=id1),
symbol2=gtirb.Symbol(name="name2", payload=None, uuid=id2),
)
s2 = gtirb.SymAddrAddr(
offset=1,
scale=2,
symbol1=gtirb.Symbol(name="name1", payload=None, uuid=id1),
symbol2=gtirb.Symbol(name="name3", payload=None, uuid=id2),
)
self.assertFalse(s1.deep_eq(s2))
s, bi = add_data_section(m, 0x4000A8)
block = add_data_block(bi, b"hello world\n")
hello = add_symbol(m, "hello", block)
# Add .text section.
s, bi = add_text_section(m, 0x400080)
# mov eax, 1
block = add_code_block(bi, b"\xB8\x01\x00\x00\x00")
start = add_symbol(m, "_start", block)
add_elf_symbol_info(m, start, block.size, "FUNC")
# mov ebx, 1
add_code_block(bi, b"\xBB\x01\x00\x00\x00")
# mov rsi, hello
operand = gtirb.SymAddrConst(0, hello)
add_code_block(bi, b"\x48\xBE\xA8\x00\x40\x00\x00\x00\x00\x00", {2: operand})
# mov rsi, 13
add_code_block(bi, b"\xBA\x0D\x00\x00\x00")
# syscall
add_code_block(bi, b"\x0F\x05")
# mov eax, 60
add_code_block(bi, b"\xB8\x3C\x00\x00\x00")
# mov edi, 0
add_code_block(bi, b"\xBF\x00\x00\x00\x00")
# syscall
add_code_block(bi, b"\x0F\x05")
# Save GTIRB file.
ir.save_protobuf("hello.gtirb")
