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")